home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / go32 / fs / fullscr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-23  |  189.5 KB  |  5,686 lines
  1. /* ---------------------------------------------------------------------- */
  2. /*                               LADYBUG                                  */
  3. /*                                                                        */
  4. /* Copyrighted 1994-1995 by Long Doan, ld@netrix.com                      */
  5. /* ---------------------------------------------------------------------- */
  6.  
  7. /* This debugger was derived from:
  8.  
  9.                        SALLY FULL SCREEN DEBUGGER
  10.                              version 0.91a
  11.                                    by
  12.                      Morten Welinder, terra@diku.dk
  13.  
  14. This debugger is free software; you can redistribute it and/or modify
  15. it under the terms of the GNU General Public License as published by
  16. the Free Software Foundation; either version 2, or (at your option)
  17. any later version.
  18.  
  19. This debugger is distributed in the hope that it will be useful,
  20. but WITHOUT ANY WARRANTY; without even the implied warranty of
  21. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22. GNU General Public License for more details.
  23.  
  24. You should have received a copy of the GNU General Public License
  25. along with djgpp; see the file COPYING.  If not, write to
  26. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.     */
  27. /* ---------------------------------------------------------------------- */
  28. #define LADYBUG_VERSION 1.02
  29. #define MAJOR_VER 1
  30. #define MINOR_VER 02
  31.  
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <ctype.h>
  35. #include <pc.h>
  36. #include <dos.h>
  37. #include <go32.h>
  38. #include <dpmi.h>
  39. #include <keys.h>
  40. #include <sys/stat.h>
  41. #include <fcntl.h>
  42. #include <setjmp.h>
  43. #define far
  44. #include "ed.h"
  45. #include "debug.h"
  46. #include "syms.h"
  47. #include "paging.h"
  48. #include "unassmbl.h"
  49. #include "npx.h"
  50. #include "serial.h"
  51. #include "fsfuncts.h"
  52. #include "xsupport.h"
  53. #include "perform.h"
  54. #include "io.h"
  55.  
  56. /* END_OF_INCLUDES */
  57. /* ---------------------------------------------------------------------- 
  58.    - Information about the initialization state of the debugger.  Actually
  59.    - I'm not sure that longjmp should ever be permitted.  
  60.    ---------------------------------------------------------------------- */
  61. int can_longjmp = 0;
  62. jmp_buf debugger_jmpbuf;
  63. /* ---------------------------------------------------------------------- 
  64.    - Information added to use com port - by Long Doan 
  65.    ---------------------------------------------------------------------- */
  66. static int using_com_port_num;
  67. int is_in_running_mode = 0;  
  68. /* ----------------------------------------------------------------------
  69.    - Display information.  
  70.    ---------------------------------------------------------------------- */
  71. int debug_screen_p;
  72. int toplines, bottomlines;
  73. int main_x1, main_x2, main_x3;
  74. /* ----------------------------------------------------------------------
  75.    - Information about panes.  
  76.    ---------------------------------------------------------------------- */
  77. #define PANECOUNT 11
  78. #define CODE_PANE_NUM       0
  79. #define REGISTER_PANE_NUM   1
  80. #define FLAG_PANE_NUM       2
  81. #define BREAKPOINT_PANE_NUM 3
  82. #define DATA_PANE_NUM       4
  83. #define NPX_PANE_NUM        5
  84. #define STACK_PANE_NUM      6
  85. #define INFO_PANE_NUM       7
  86. #define WHEREIS_PANE_NUM    8
  87. #define MODULE_PANE_NUM     9
  88. #define HELP_PANE_NUM      10
  89. static int pane, pane_positions[PANECOUNT], pane_pos;
  90. static int pane_offset[PANECOUNT];
  91. static word32 data_dump_origin, data_dump_last, data_dump_size;
  92. static word32 code_dump_origin, code_dump_last;
  93. static word32 *code_pane_pos, *stack_dump_pos;
  94. static int stack_dump_origin, stack_dump_last, stack_dump_more;
  95. static int breakpoint_origin;
  96. static word32 *whereis_pane_sym;
  97. static char **module_pane_text;
  98. static char **help_pane_text;
  99. static int whereis_sym_count, whereis_origin;
  100. static int module_text_count, module_origin;
  101. static int help_text_count, help_origin;
  102. static int reg_pane_origin, flag_pane_origin;
  103. static int code_pane_active;
  104. static int npx_pane_active;
  105. static int stack_pane_active;
  106. static int info_pane_active;
  107. static int whereis_pane_active;
  108. static int module_pane_active;
  109. static int help_pane_active;
  110. static int running_xsupport = 0;
  111. static char active_pane_name[20];
  112. /* ----------------------------------------------------------------------
  113.    - Menus 
  114.    ---------------------------------------------------------------------- */
  115. static MENU_ITEM File_Sub_Menu[] = { 
  116.        {"Current item              ", 1        , ""         , 0},
  117.        {"Read/write log      ~^X^F~", ITEM_TYPE, "\030\006" , 0},
  118.        {"View debug registers      ", ITEM_TYPE, ""         , 0},
  119.        {"Resize Screen             ", ITEM_TYPE, ""         , 0},
  120.        {"Monochrome Mode     ~^X m~", ITEM_TYPE, "\030m"    , 0},
  121.        {"Color Mode                ", ITEM_TYPE, ""         , 0},
  122.        {"Redirect IO               ", ITEM_TYPE, ""         , 0},
  123.        {"Save/load context   ~^X^V~", ITEM_TYPE, "\030\026" , 0},
  124.        {"Exit                ~^X^C~", ITEM_TYPE, "\030\003" , 0},
  125.        {0                           , 0        , ""         , 0}
  126. };
  127. static MENU_ITEM Pane_Sub_Menu[] = {
  128.        {"Current     ", 1        , "" , 0},
  129.        {"~P~revious  ", ITEM_TYPE, "p", 0},
  130.        {"~N~ext      ", ITEM_TYPE, "n", 0},
  131.        {"~B~reakpoint", ITEM_TYPE, "b", 0},
  132.        {"~C~ode      ", ITEM_TYPE, "c", 0},
  133.        {"~D~ata      ", ITEM_TYPE, "d", 0},
  134.        {"~F~lags     ", ITEM_TYPE, "f", 0},
  135.        {"~H~elp      ", ITEM_TYPE, "h", 0},
  136.        {"~I~nfo      ", ITEM_TYPE, "i", 0},
  137.        {"~M~odule    ", ITEM_TYPE, "m", 0},
  138.        {"Np~X~       ", ITEM_TYPE, "x", 0},
  139.        {"~R~egisters ", ITEM_TYPE, "r", 0},
  140.        {"~S~tack     ", ITEM_TYPE, "s", 0},
  141.        {"~W~here-is  ", ITEM_TYPE, "w", 0},
  142.        {"Resi~Z~e    ", ITEM_TYPE, "z", 0},
  143.        {0             , 0        , "" , 0}
  144. };
  145. static MENU_ITEM Help_Sub_Menu[] = {
  146.        {"Current     ", 1        , "" , 0},
  147.        {"~A~bout     ", ITEM_TYPE, "a", 0},
  148.        {"~H~elp      ", ITEM_TYPE, "h", 0},
  149.        {0             , 0        , "" , 0}
  150. };
  151. static MENU_ITEM Misc_Sub_Menu[] = {
  152.        {"Current      ", 1        , "" , 0},
  153.        {"~U~ser screen", ITEM_TYPE, "u", 0},
  154.        {"~E~valuate   ", ITEM_TYPE, "e", 0},
  155.        {"~R~efresh    ", ITEM_TYPE, "r", 0},
  156.        {0              , 0        , "" , 0}
  157. };
  158. static MENU_ITEM Main_Menu[] = {
  159.        {"Current "     , 1        , "" , 0            },
  160.        {"~F~ile  "     , MENU_TYPE, "f", File_Sub_Menu},
  161.        {"~P~ane  "     , MENU_TYPE, "p", Pane_Sub_Menu},
  162.        {"~L~ocal menu ", ITEM_TYPE, "l", 0            },
  163.        {"~M~isc  "     , MENU_TYPE, "m", Misc_Sub_Menu},
  164.        {"~H~elp  "     , MENU_TYPE, "h", Help_Sub_Menu},
  165.        {0           , 0        , "" , 0             }
  166. };
  167. /* ----------------------------------------------------------------------
  168.    - Odds and ends.
  169.    ---------------------------------------------------------------------- */
  170. #define MAXINSTLEN 16
  171. static int first_step;
  172. static int escaped, control_c, control_x;
  173. static word32 main_entry;
  174. static int has_npx = 1;
  175. NPX npx; /* non-static because declared so in "npx.h" */
  176. static char hexchars[] = "0123456789abcdef";
  177. #define MAX_REGISTERS 75
  178. #define SCROLL_COUNT 5
  179. #define ACTION_HIST_SIZE 40
  180. static word32 registers[MAX_REGISTERS];
  181. static char last_addr[4096];
  182. /* ---------------------------------------------------------------------- 
  183.    - The presentation order of registers in the register pane.  The three
  184.    - tables must of course match.  
  185.    ---------------------------------------------------------------------- */
  186. static char *regs_names[] = {
  187.   "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp",
  188.   "cs",  "ds",  "es",  "fs",  "gs",  "ss",
  189.   "eip", "flg" };
  190. static word32 *regs_addr[] = {
  191.   &a_tss.tss_eax, &a_tss.tss_ebx, &a_tss.tss_ecx, &a_tss.tss_edx,
  192.   &a_tss.tss_esi, &a_tss.tss_edi, &a_tss.tss_ebp, &a_tss.tss_esp,
  193.   (word32 *)&a_tss.tss_cs, (word32 *)&a_tss.tss_ds,
  194.   (word32 *)&a_tss.tss_es, (word32 *)&a_tss.tss_fs,
  195.   (word32 *)&a_tss.tss_gs, (word32 *)&a_tss.tss_ss,
  196.   &a_tss.tss_eip, &a_tss.tss_eflags };
  197. /* ----------------------------------------------------------------------
  198.    - g: general, !: special, s: segment, f: flags, \0: end-of-table 
  199.    ---------------------------------------------------------------------- */
  200. static char regs_type[] = "ggggggg!ssssss!f";
  201. /* ---------------------------------------------------------------------- 
  202.    - Breakpoint data.  When breakpoints are actually put into the cpu debug
  203.    - registers, data breakpoints have first priority.  Any code breakpoints
  204.    - left over are set by patching the code to contain "Int 3".  
  205.    ---------------------------------------------------------------------- */
  206. typedef enum { BP_Code = 0, BP_Write = 1, BP_Read = 3 } BP_TYPE;
  207. typedef enum { BP_Normal = 0, BP_Count = 1, BP_Condition = 2 } BP_SUB_TYPE;
  208.  
  209. typedef struct
  210. {
  211.   word32 addr;
  212.   BP_TYPE type;
  213.   BP_SUB_TYPE sub_type;
  214.   int count;
  215.   char condition[200];
  216.   unsigned char length;       /* 1, 2, or 4 bytes */
  217.   unsigned char saved;
  218.   unsigned char savedbyte;    /* Patched-away byte. */
  219. } BP_ENTRY;
  220.  
  221. static int breakpoint_count;
  222. static BP_ENTRY *breakpoint_table;
  223. static unsigned char int03 = 0xcc;
  224.  
  225. #define MAX_UNDO 5           
  226. typedef struct undo_data {
  227.         word32 addr;
  228.         word32 value;
  229.         int size;
  230. } UNDO_DATA;
  231. typedef struct {
  232.         struct undo_data data[MAX_UNDO];
  233.         int count;                      
  234.         void (*free_entry)(word32);
  235. } UNDO_STRUCT;
  236. static UNDO_STRUCT data_undo;
  237. static UNDO_STRUCT register_undo;
  238. static UNDO_STRUCT breakpoint_undo;
  239. static UNDO_STRUCT npx_undo;
  240. /* ---------------------------------------------------------------------- */
  241. static void
  242. test_npx (void)
  243. { asm ("push    %eax            \n\
  244.     push    %ebx            \n\
  245.         movl    %cr0, %eax      \n\
  246.     andl    $0x04, %eax     \n\
  247.         jnz     Has_387         \n\
  248.         clts                    \n\
  249.         fninit                  \n\
  250.         movl    $_npx, %eax     \n\
  251.         movl    $0x5a5ah, (%eax)\n\
  252.         fnstsw  (%eax)          \n\
  253.         cmpb    $0, (%eax)      \n\
  254.         jne     No_387          \n\
  255.         fnstcw  (%eax)          \n\
  256.         movw    (%eax), %bx     \n\
  257.         and     $0x103f, %bx    \n\
  258.         cmpw    $0x3f, %bx      \n\
  259.         jne     No_387          \n\
  260.         fld1                    \n\
  261.         fldz                    \n\
  262.         fdiv                    \n\
  263.         fld     %st             \n\
  264.         fchs                    \n\
  265.         fcompp                  \n\
  266.         fstsw   (%eax)          \n\
  267.         movw    (%eax), %bx     \n\
  268.         sahf                    \n\
  269.         je      No_387          \n\
  270. Has_387:                        \n\
  271.         movl    $1, _has_npx    \n\
  272.         jmp     Test_done       \n\
  273. No_387:                         \n\
  274.         movl    $0, _has_npx    \n\
  275. Test_done:                      \n\
  276.         pop     %ebx            \n\
  277.         pop     %eax            "
  278.   );
  279. }
  280. /* ---------------------------------------------------------------------- */
  281. static void
  282. save_npx (void)
  283. {
  284. asm(                          "\n\
  285.     inb     $0xa0,%al      \n\
  286.         testb   $0x20,%al      \n\
  287.     jz      Lfclex_done    \n\
  288.     xorl    %eax,%eax      \n\
  289.     outb    %al,$0xf0      \n\
  290.     movb    $0x20,%al      \n\
  291.     outb    %al,$0xa0      \n\
  292.     outb    %al,$0x20      \n\
  293. Lfclex_done:                   \n\
  294.     movl    $_npx, %eax    \n\
  295.     fnsave  (%eax)         \n\
  296.     fwait                  "
  297.     );
  298. }
  299. /* ---------------------------------------------------------------------- */
  300. static void
  301. load_npx (void)
  302. {
  303. asm(                                                                   "\n\
  304.         movl    $_npx, %eax                                             \n\
  305.         frstor  (%eax)                                                  "
  306.     );
  307. /*  After line 1 */
  308. /*  movb    $0,4(%eax)  */
  309. /* clear pending exceptions */ 
  310. /* At least on my 486 there is no need to clear pending exceptions.  */
  311. }
  312. /* ---------------------------------------------------------------------- */
  313. /* Display the debugger screen (if not already displayed).  */
  314. static void
  315. debug_screen (void)
  316. { if (!debug_screen_p)
  317.     {
  318.       user_screen_save = get_screen ();
  319.       if (using_com_port_num)
  320.         screen_scroll (rows);
  321.       put_screen (debug_screen_save);
  322.       debug_screen_p = 1;
  323.     }
  324. }
  325. /* ---------------------------------------------------------------------- */
  326. /* Display the user screen (if not already displayed).  */
  327. static void
  328. user_screen (void)
  329. { if (debug_screen_p)
  330.     {
  331.       if (using_com_port_num)
  332.         screen_scroll (rows);
  333.       else
  334.         put_screen (user_screen_save);
  335.       free (user_screen_save);
  336.       debug_screen_p = 0;
  337.     }
  338. }
  339. /* ---------------------------------------------------------------------- */
  340. static void
  341. free_do_nothing (word32 addr)
  342. {
  343. }                                                    
  344. /* ---------------------------------------------------------------------- */
  345. static void
  346. free_breakpoint (word32 addr)
  347. { BP_ENTRY *bp_to_free = (BP_ENTRY *)addr;
  348.   free (bp_to_free);
  349. }                                                    
  350. /* ---------------------------------------------------------------------- */
  351. static void
  352. free_npx (word32 addr)
  353. { NPX *npx_to_free = (NPX *)addr;
  354.   free (npx_to_free);
  355. }                                                    
  356. /* ---------------------------------------------------------------------- */
  357. static void
  358. init_undo (UNDO_STRUCT *what_undo, void (*free_func)(word32))
  359. { what_undo->count = 0;                                     
  360.   what_undo->free_entry = free_func;
  361. }
  362. /* ---------------------------------------------------------------------- */
  363. static void
  364. reinit_undo (UNDO_STRUCT *what_undo)
  365. { while (what_undo->count)                 
  366.   { what_undo->count--;
  367.     what_undo->free_entry (what_undo->data[what_undo->count].value);
  368.   }
  369. }
  370. /* ---------------------------------------------------------------------- */
  371. static void
  372. put_undo (UNDO_STRUCT *what_undo, word32 addr, word32 val, int size)
  373. { if (what_undo->count == MAX_UNDO)
  374.   { int i;                          
  375.     what_undo->free_entry (what_undo->data[0].value);
  376.     for (i = 1; i < what_undo->count; i++)
  377.     { what_undo->data[i - 1].addr  = what_undo->data[i].addr;
  378.       what_undo->data[i - 1].value = what_undo->data[i].value;
  379.       what_undo->data[i - 1].size  = what_undo->data[i].size;
  380.     }
  381.     what_undo->count--;
  382.   }
  383.   what_undo->data[what_undo->count].addr  = addr;
  384.   what_undo->data[what_undo->count].value = val;
  385.   what_undo->data[what_undo->count].size  = size;
  386.   what_undo->count++;
  387. }
  388. /* ---------------------------------------------------------------------- */
  389. static int
  390. get_undo (UNDO_STRUCT *what_undo, word32 *addr, word32 *val, int *size)
  391. { if (what_undo->count <= 0)
  392.     return (0);      
  393.   what_undo->count--;                            
  394.   *addr = what_undo->data[what_undo->count].addr;
  395.   *val  = what_undo->data[what_undo->count].value;
  396.   *size = what_undo->data[what_undo->count].size;
  397.   return (1);
  398. }
  399. /* ---------------------------------------------------------------------- */
  400. typedef enum { not, com, mul, divi, add, sub, shl, shr,
  401.            and, xor, or, land, lor, less, greater, not_equal,
  402.                less_equal, great_equal, equal} OPR_Name;
  403. typedef struct {
  404.     char *str;
  405.     OPR_Name name;
  406. } OPR_TYPE;
  407. typedef struct {
  408.         OPR_TYPE *opers;
  409.         int opers_num;
  410. } OPR_CLASS;
  411.  
  412. static OPR_TYPE opers0[] = {     /* Lowest priority first */
  413.        {"||", lor        },
  414.        {"&&", land       },
  415.        {0   , 0          }
  416. };
  417. static OPR_TYPE opers1[] = {
  418.        {"==", equal      },
  419.        {">=", great_equal},
  420.        {"<=", less_equal },
  421.        {"!=", not_equal  },
  422.        {">" , greater    },
  423.        {"<" , less       },
  424.        {0   , 0          }
  425. };
  426. static OPR_TYPE opers2[] = {
  427.        {"|" , or         },
  428.        {"^" , xor        },
  429.        {"&" , and        },
  430.        {0   , 0          }
  431. };
  432. static OPR_TYPE opers3[] = {
  433.        {">>", shr        },
  434.        {"<<", shl        },
  435.        {0   , 0          }
  436. };
  437. static OPR_TYPE opers4[] = {
  438.        {"-" , sub        },
  439.        {"+" , add        },
  440.        {0   , 0          }
  441. };
  442. static OPR_TYPE opers5[] = {
  443.        {"/" , divi       },
  444.        {"*" , mul        },
  445.        {0   , 0          }
  446. };
  447. static OPR_TYPE opers6[] = {     /* Unary, left until the end. */
  448.        {"~" , com        },
  449.        {"!" , not        },
  450.        {0   ,0           }
  451. };
  452. static OPR_CLASS operators[] = {
  453.        {opers0, 2        },
  454.        {opers1, 6        },
  455.        {opers2, 3        },
  456.        {opers3, 2        },
  457.        {opers4, 2        },
  458.        {opers5, 2        },
  459.        {opers6, 2        },
  460.        {0     , 0        }
  461. };
  462. static char l_str[200], r_str[200];
  463. /* ---------------------------------------------------------------------- */
  464. static char *
  465. i_strstr (char *s1, char *s2)
  466. { int i, len1, len2;
  467.   if (!s1 || !s2)
  468.     return (0);
  469.   len1 = strlen (s1);
  470.   len2 = strlen (s2);
  471.   if (!len2)
  472.     return (s1);
  473.   if (!len1 || len1 < len2)
  474.     return (0);
  475.   for (i = len1 - len2; i >= 0; i--)
  476.     if (strncmp (s1 + i, s2, len2) == 0)
  477.       return (s1 + i);
  478.   return (0);
  479. }
  480. /* ---------------------------------------------------------------------- */
  481. static void
  482. break_up (char *expr, OPR_Name *opr_num, int *found)
  483. { word32 pos, maxpos;
  484.   int i, j, k = 1, len = strlen(expr);
  485.   char *ptr = 0, *testptr = 0;
  486.  
  487.   l_str[0] = '\0';
  488.   r_str[0] = '\0';
  489.   *found = 0;
  490.   for (i = 0; !(*found) && operators[i].opers; i++)
  491.   { maxpos = 0;
  492.     k = 0;
  493.     for (j = 0; j < operators[i].opers_num; j++)
  494.     { testptr = i_strstr(expr, operators[i].opers[j].str);
  495.       pos = (word32)testptr;
  496.       if (pos)
  497.       { pos -= (word32)expr;
  498.         if (pos > maxpos)
  499.         { maxpos = pos;
  500.           ptr = testptr;
  501.           k = j;
  502.         }
  503.         *found = 1;
  504.       }
  505.     }
  506.   }
  507.   if (*found)
  508.   { i--;
  509.     len -= strlen (ptr);
  510.     if (len > 0)
  511.       strncpy(l_str, expr, len);
  512.     l_str[len] = 0;
  513.     len = strlen (l_str) - 1;
  514.     while (len >= 0 && l_str[len] == ' ')
  515.       l_str[len--] = 0;
  516.     ptr++;
  517.     *opr_num = operators[i].opers[k].name;
  518.     switch (*opr_num)
  519.     {
  520.       case shl:
  521.       case shr:
  522.       case land:
  523.       case lor:
  524.       case not_equal:
  525.       case less_equal:
  526.       case great_equal:
  527.       case equal:
  528.     ptr++;
  529.         break;
  530.       default:
  531.         break;
  532.     }
  533.     while (*ptr && *ptr == ' ')
  534.       ptr++;
  535.     strcpy(r_str, ptr);
  536.   }
  537. }
  538. /* ---------------------------------------------------------------------- */
  539. static long
  540. parse_expression_without_paren (int size, char *expr, int *okp)
  541. {
  542.   long l_val, r_val, result = 0;
  543.   char *l_expr, *r_expr;
  544.   OPR_Name opr_num;
  545.   int found;
  546.  
  547.   break_up(expr, &opr_num, &found);
  548.   if (found)
  549.   { if (opr_num == divi && expr[0] == '/')
  550.     { result = syms_name2val(expr);
  551.       if (undefined_symbol)
  552.       { *okp = ParseError_undef;
  553.         return 0;
  554.       }
  555.       *okp = ParseError_ok;
  556.     } else
  557.     { l_expr = strdup(l_str);
  558.       r_expr = strdup(r_str);
  559.       r_val = parse_expression_without_paren (size, r_expr, okp);
  560.       free (r_expr);
  561.       if (*okp != ParseError_ok)
  562.       { free (l_expr);
  563.         return 0;
  564.       }
  565.       l_val = parse_expression_without_paren (size, l_expr, okp);
  566.       free (l_expr);
  567.       if (*okp != ParseError_ok)
  568.         return 0;
  569.       *okp = ParseError_ok;
  570.       switch (opr_num)
  571.       { case not:
  572.           result = !r_val;
  573.           break;
  574.         case com:
  575.           result = ~r_val;
  576.           break;
  577.         case mul:
  578.       result = l_val * r_val;
  579.           break;
  580.         case divi:
  581.           if (r_val == 0)
  582.           { *okp = ParseError_divzero;
  583.         return 0;
  584.           } else
  585.             result = l_val / r_val;
  586.           break;
  587.         case add:
  588.           result = l_val + r_val;
  589.           break;
  590.         case sub:
  591.           result = l_val - r_val;
  592.           break;
  593.         case shl:
  594.           result = l_val << r_val;
  595.           break;
  596.         case shr:
  597.           result = l_val >> r_val;
  598.           break;
  599.         case and:
  600.           result = l_val & r_val;
  601.           break;
  602.         case xor:
  603.           result = l_val ^ r_val;
  604.           break;
  605.         case or :
  606.           result = l_val | r_val;
  607.           break;
  608.         case land:
  609.           result = l_val && r_val;
  610.           break;
  611.         case lor:
  612.           result = l_val || r_val;
  613.           break;
  614.         case equal:
  615.           result = (l_val == r_val);
  616.           break;
  617.         case great_equal:
  618.           result = (l_val >= r_val);
  619.           break;
  620.         case less_equal:
  621.           result = (l_val <= r_val);
  622.           break;
  623.         case not_equal:
  624.           result = (l_val != r_val);
  625.           break;
  626.         case greater:
  627.           result = (l_val > r_val);
  628.           break;
  629.         case less:
  630.           result = (l_val < r_val);
  631.           break;
  632.       }
  633.     }
  634.   } else
  635.   { result = syms_name2val(expr);
  636.     if (undefined_symbol)
  637.     {
  638.       *okp = ParseError_undef;
  639.       return 0;
  640.     }
  641.     *okp = ParseError_ok;
  642.   }
  643.   switch (size)
  644.   { case 1:
  645.       return (short)(result & 0xff);
  646.     case 2:
  647.       return (int)(result & 0xffff);
  648.     case 4:          /* Fall through */
  649.     default:
  650.       return result;
  651.   }
  652. }
  653. /* ---------------------------------------------------------------------- */
  654. long
  655. parse_expression (int size, char *expr, int *okp)
  656. { int len = strlen (expr);
  657.   char *new_exp1 = alloca (len * 2 + 10), *new_exp2 = alloca (len * 2 + 10);
  658.   int left_paren = 0, right_paren = 0, i, found = 1;
  659.   char lookfor = ']';
  660.   long temp_value;
  661.              
  662.   *okp = ParseError_ok;
  663.   strcpy (new_exp1, expr);
  664.   while (found)
  665.   { for (i = 0; (i < len) && (new_exp1[i] != lookfor); i++)
  666.       ;            
  667.     if (i == len)
  668.       i = len - 1;
  669.     if (new_exp1[i] != lookfor)
  670.     { if (lookfor == ']')
  671.         lookfor = ')';
  672.       else
  673.         found = 0;
  674.     } else
  675.     { right_paren = i;        
  676.       if (lookfor == ']')
  677.         lookfor = '[';
  678.       else
  679.         lookfor = '(';
  680.       for (i = right_paren - 1; (i >= 0) && (new_exp1[i] != lookfor); i--)
  681.         ;         
  682.       if (i < 0)
  683.         i = 0;
  684.       if (new_exp1[i] != lookfor)
  685.       { *okp = ParseError_paren;
  686.         return (0);
  687.       }
  688.       left_paren = i;
  689.       temp_value = 0;
  690.       for (i = left_paren + 1; (i < right_paren); i++, temp_value++)
  691.         new_exp2[temp_value] = new_exp1[i];
  692.       new_exp2[temp_value] = 0;                                    
  693.       temp_value = parse_expression (size, new_exp2, okp);
  694.       if (*okp != ParseError_ok)
  695.         return (0);            
  696.       if (lookfor == '[')
  697.       { switch (new_exp1[++right_paren])
  698.         { case 'b':
  699.             i = 1;
  700.             break;
  701.           case 'h':
  702.             i = 2;
  703.             break;
  704.           case 'f':
  705.             i = 4;
  706.             break;
  707.           default:
  708.             i = 4;
  709.             right_paren--;
  710.             break;
  711.         }
  712.         if (valid_addr (temp_value, i))
  713.           read_child (temp_value, &temp_value, i);
  714.         else
  715.         { *okp = ParseError_addr;
  716.           return (0);
  717.         }      
  718.         switch (i)
  719.         { case 1:
  720.             temp_value &= 0x000000ff;
  721.             break;
  722.           case 2:
  723.             temp_value &= 0x0000ffff;
  724.             break;  
  725.         }
  726.       }
  727.       
  728.       strncpy(l_str, new_exp1, left_paren);
  729.       strcpy(r_str, new_exp1 + right_paren + 1);
  730.       l_str[left_paren] = 0;
  731.       r_str[len - right_paren + 1] = 0;
  732.       sprintf (new_exp2, "%s0x%08lx%s", l_str, temp_value, r_str);
  733.       strcpy (new_exp1, new_exp2);
  734.       len = strlen (new_exp1); 
  735.  
  736.       if (lookfor == '[')
  737.         lookfor = ']';
  738.       else
  739.         lookfor = ')';
  740.     }
  741.   }                                          
  742.   return (parse_expression_without_paren (size, new_exp1, okp));
  743. }
  744. /* ---------------------------------------------------------------------- */
  745. static long
  746. read_eval (int *okp, char *starttext)
  747. {
  748.   long result;
  749.  
  750.   *okp = !read_string (starttext);
  751.   if (*okp && read_buffer[0] != '\0')
  752.   {
  753.     result = parse_expression (4, read_buffer, okp);
  754.     if (*okp == ParseError_ok)
  755.     { *okp = 1;
  756.       return (result);
  757.     }
  758.     switch (*okp)
  759.     { case ParseError_addr:
  760.         message (CL_Error, "Reference to an invalid address.");
  761.         break;  
  762.       case ParseError_divzero:
  763.         message (CL_Error, "Divide by zero.");
  764.         break;
  765.       case ParseError_paren:
  766.         message (CL_Error, "Unbalanced [] or ().");
  767.         break;
  768.       case ParseError_syntax:
  769.         message (CL_Error, "Syntax error.");
  770.         break;                          
  771.       case ParseError_undef:
  772.         message (CL_Error, "Undefined symbol.");
  773.         break;
  774.     }     
  775.     *okp = 0;
  776.     return (0);
  777.   }
  778.   else
  779.     return *okp = 0;
  780. }
  781. /* ---------------------------------------------------------------------- */
  782. inline static int
  783. valid_instaddr (word32 vaddr)
  784. {
  785.   return valid_addr (vaddr, MAXINSTLEN);
  786. }
  787. /* ---------------------------------------------------------------------- */
  788. /* Set physical breakpoint registers from virtual ones.  */
  789. static void
  790. activate_breakpoints (void)
  791. {
  792.   int b, no;
  793.   BP_ENTRY *bep;
  794.  
  795.   no = 0;
  796.   edi.dr[7] = 0;
  797.   /* First handle data breakpoints.  */
  798.   for (b = 0, bep = breakpoint_table; b < breakpoint_count; b++, bep++)
  799.     if (no <= 3 && bep->type != BP_Code)
  800.       {
  801.     bep->saved = 0;
  802.     edi.dr[7] |= ((bep->type + ((bep->length - 1) << 2)) << (16 + 4 * no)
  803.               | (2 << (2 * no)));
  804.     edi.dr[no] = bep->addr + edi.app_base;
  805.     no++;
  806.       }
  807.  
  808.   /* Now handle code breakpoint.  */
  809.   for (b = 0, bep = breakpoint_table; b < breakpoint_count; b++, bep++)
  810.     if (bep->type == BP_Code)
  811.       if (no <= 3)
  812.     {
  813.       bep->saved = 0;
  814.       edi.dr[7] |= ((BP_Code << (16 + 4 * no)) | (2 << (2 * no)));
  815.       edi.dr[no] = bep->addr + edi.app_base;
  816.       no++;
  817.       edi.dr[7] |= 0x00000300L;  /* For 386s we set GE & LE bits.  */
  818.     }
  819.       else
  820.     {
  821.       bep->saved = valid_addr (bep->addr, 1);
  822.       if (bep->saved)
  823.         {
  824.           read_child (bep->addr, &bep->savedbyte, 1);
  825.           write_child (bep->addr, &int03, 1);
  826.         }
  827.     }
  828. }
  829. /* ---------------------------------------------------------------------- */
  830. /* Un-patch code.  */
  831. static void
  832. deactivate_breakpoints (void)
  833. { int b;
  834.   BP_ENTRY *bep;
  835.  
  836.   for (b = 0, bep = breakpoint_table; b < breakpoint_count; b++, bep++)
  837.     if (bep->saved)
  838.       write_child (bep->addr, &bep->savedbyte, 1);
  839. }
  840. /* ---------------------------------------------------------------------- */
  841. static int
  842. get_breakpoint (BP_TYPE type, int length, word32 addr)
  843. { int b;
  844.  
  845.   for (b = 0; b < breakpoint_count; b++)
  846.     if ((breakpoint_table[b].type == type) &&
  847.         ((breakpoint_table[b].length == length) || (length == -1)) &&
  848.         (breakpoint_table[b].addr == addr))
  849.       return b;
  850.   return -1;
  851. }
  852. /* ---------------------------------------------------------------------- */
  853. static void
  854. reset_breakpoint (int b)
  855. { BP_ENTRY *del_bp = malloc (sizeof (BP_ENTRY));
  856.   
  857.   del_bp->addr     = breakpoint_table[b].addr;
  858.   del_bp->type     = breakpoint_table[b].type;
  859.   del_bp->length   = breakpoint_table[b].length;
  860.   del_bp->sub_type = breakpoint_table[b].sub_type;
  861.   del_bp->count    = breakpoint_table[b].count;
  862.   strcpy (del_bp->condition, breakpoint_table[b].condition);
  863.   put_undo (&breakpoint_undo, 1, (word32)del_bp, 1);
  864.   breakpoint_table[b] = breakpoint_table[--breakpoint_count];
  865.   breakpoint_table
  866.     = realloc (breakpoint_table, breakpoint_count * sizeof (BP_ENTRY));
  867. }
  868. /* ---------------------------------------------------------------------- */
  869. static int
  870. set_breakpoint (BP_TYPE type, int length, word32 addr)
  871. { int b;
  872.  
  873.   b = breakpoint_count;
  874.   breakpoint_table
  875.     = realloc (breakpoint_table, ++breakpoint_count * sizeof (BP_ENTRY));
  876.   breakpoint_table[b].addr = addr;
  877.   breakpoint_table[b].type = type;
  878.   breakpoint_table[b].length = length;
  879.   breakpoint_table[b].sub_type = 0;
  880.   breakpoint_table[b].count = 0;
  881.   breakpoint_table[b].condition[0] = '\0';
  882.   return b;
  883. }
  884. /* ---------------------------------------------------------------------- */
  885. static void
  886. format_type (char *output, char *input)
  887. { int ok;
  888.   long temp = parse_expression (4, input, &ok);
  889.   
  890.   if (ok != ParseError_ok)
  891.     temp = 4;
  892.   switch (temp)
  893.   { case 0:
  894.       sprintf (output, "%ld (%s)", temp, "Code breakpoint");
  895.       break;
  896.     case 1:
  897.       sprintf (output, "%ld (%s)", temp, "Data-write breakpoint");
  898.       break;
  899.     case 3:
  900.       sprintf (output, "%ld (%s)", temp, "Data-read/write breakpoint");
  901.       break;                                            
  902.     default:
  903.       sprintf (output, "%ld (%s)", temp, "Invalid breakpoint type");
  904.       break;
  905.   }
  906. }
  907. /* ---------------------------------------------------------------------- */
  908. static void
  909. format_subt (char *output, char *input)
  910. { int ok;
  911.   long temp = parse_expression (4, input, &ok);
  912.   
  913.   if (ok != ParseError_ok)
  914.     temp = 3;
  915.   switch (temp)
  916.   { case 0:
  917.       sprintf (output, "%ld (%s)", temp, "Normal breakpoint");
  918.       break;
  919.     case 1:
  920.       sprintf (output, "%ld (%s)", temp, "Countdown breakpoint");
  921.       break;
  922.     case 2:
  923.       sprintf (output, "%ld (%s)", temp, "Conditional breakpoint");
  924.       break;                                            
  925.     default:
  926.       sprintf (output, "%ld (%s)", temp, "Invalid breakpoint type");
  927.       break;
  928.   }
  929. }
  930. /* ---------------------------------------------------------------------- */
  931. static void
  932. init_type (char *output, char *input, word32 addr)
  933. { char *temp = alloca (16);
  934.  
  935.   sprintf (input, "%d", *(int *)addr);
  936.   sprintf (temp, "%08lx", *(word32 *)addr);
  937.   format_type (output, temp);
  938. }
  939. /* ---------------------------------------------------------------------- */
  940. static void
  941. init_subt (char *output, char *input, word32 addr)
  942. { char *temp = alloca (16);
  943.  
  944.   sprintf (input, "%d", *(int *)addr);
  945.   sprintf (temp, "%08lx", *(word32 *)addr);
  946.   format_subt (output, temp);
  947. }
  948. /* ---------------------------------------------------------------------- */
  949. static int
  950. edit_breakpoint (int bp_num)
  951. { word32 addr;
  952.   int    type = 0, sub_type = 0, count = 0, size = 4, ret = 5;
  953.   char   *condition = alloca (max_cols);
  954.   static DIALOG_ITEM dialog_data[] = {
  955.     {"Address  :", 0 , 50, 1, format_addr, eval_word, init_addr, editor},
  956.     {"Type     :", 0 , 30, 1, format_type, eval_word, init_type, editor},
  957.     {"Class    :", 0 , 30, 1, format_subt, eval_word, init_subt, editor},
  958.     {"Count    :", 0 , 10, 1, format_deci, eval_word, init_deci, editor},
  959.     {"Size     :", 0 , 02, 1, format_deci, eval_word, init_deci, editor},
  960.     {"Condition:", 0 , 70, 1, format_asis, eval_asis, init_asis, editor},
  961.     {0           , 0 , 0 , 0, 0          , 0        , 0        , 0     }
  962.   };
  963.   static BUTTON_ITEM button_data[] = {
  964.     {"   OK   ", 0, action_done},
  965.     {" Cancel ", 0, action_done},
  966.     {0         , 0, 0          }
  967.   };
  968.  
  969.   addr      = breakpoint_table[bp_num].addr;
  970.   type      = breakpoint_table[bp_num].type;
  971.   sub_type  = breakpoint_table[bp_num].sub_type;
  972.   count     = breakpoint_table[bp_num].count;
  973.   size      = breakpoint_table[bp_num].length;
  974.   strcpy(condition,breakpoint_table[bp_num].condition);
  975.   if (size != 1 && size != 2)
  976.     size = 4;
  977.  
  978.   dialog_data[0].return_addr = (word32)&addr;
  979.   dialog_data[1].return_addr = (word32)&type;
  980.   dialog_data[2].return_addr = (word32)&sub_type;
  981.   dialog_data[3].return_addr = (word32)&count;
  982.   dialog_data[4].return_addr = (word32)&size;
  983.   dialog_data[5].return_addr = (word32)condition;
  984.   dialog ("Edit Breakpoint", dialog_data, button_data, &ret);
  985.   if (ret == 1)
  986.   { if (size != 1 && size != 2)
  987.       size = 4;
  988.     breakpoint_table[bp_num].addr     = addr;
  989.     breakpoint_table[bp_num].type     = type;
  990.     breakpoint_table[bp_num].sub_type = sub_type;
  991.     breakpoint_table[bp_num].count    = count;
  992.     breakpoint_table[bp_num].length   = size;
  993.     strcpy(breakpoint_table[bp_num].condition,condition);
  994.     return (0);
  995.   } else
  996.     return (1);
  997. }
  998. /* ---------------------------------------------------------------------- */
  999. /* From ORIGIN skip COUNT instructions forward (positive count) or
  1000.    backwards (negative count).  Backwards skipping cannot be assumed to
  1001.    be working 100% perfectly, but in the presense of debug information
  1002.    it is probably very, very close.
  1003.  
  1004.    This function works poorly close to the extremes of segments.  */
  1005.  
  1006. static int
  1007. code_skip (int origin, int count)
  1008. {
  1009.   int len, *next, i, j, k, instcount, done, leave;
  1010.   char *state, *inst, *source;
  1011.  
  1012.   if (count >= 0)
  1013.   { while (count-- > 0)
  1014.       if (valid_instaddr (origin))
  1015.       { unassemble_proper (origin, &len);
  1016.         origin += len;
  1017.       }    else
  1018.         origin ++;
  1019.     return origin;
  1020.   } else
  1021.   { count = -count;
  1022.     instcount = MAXINSTLEN * (count + 16) + 1;
  1023.     next = alloca (instcount * sizeof (int));
  1024.     memset (next, 0, instcount * sizeof (int));
  1025.     state = alloca (instcount * sizeof (char));
  1026.     memset (state, 0, instcount * sizeof (char));
  1027.  
  1028.     done = 0;
  1029.     do
  1030.     { for (i = 0; i < 2 * count; i++)
  1031.       { done++;
  1032.         j = origin - done;
  1033.         if (valid_instaddr (j))
  1034.         { inst = unassemble_proper (j, &len);
  1035.           source = unassemble_source (j);
  1036.           next[done] = j + len;
  1037.           if (source)
  1038.           { leave = 0;
  1039.             k = done;
  1040.             while (j < origin && state[k] == 0 && !leave)
  1041.             { j++;
  1042.               state[k--] = 2;
  1043.               while (len-- > 1)
  1044.               { j++;
  1045.                 state[k--] = 3;
  1046.               }
  1047. /* -------------------------------------------------------------------
  1048.    - Since code and data is "never" mixed in 32 bit code we don't need this.  
  1049.    -------------------------------------------------------------------*/
  1050. #if 0
  1051.               leave = (strncmp (inst, "jmp", 3) == 0
  1052.                        || strncmp (inst, "ret", 3) == 0
  1053.                        || strncmp (inst, "iret", 4) == 0);
  1054. #endif
  1055.               if (!leave)
  1056.                 inst = unassemble_proper (j, &len);
  1057.             }
  1058.           }
  1059.         } else
  1060.         { state[done] = 2;
  1061.           next[done] = j + 1;
  1062.         }
  1063.       }
  1064.       j = 1;
  1065.       k = count;
  1066.       while (k > 0 && j <= done && state[j] >= 2)
  1067.         if (state[j++] == 2)
  1068.           k--;
  1069.     } while (k > 0 && done + 2 * count <= instcount);
  1070.     if (k == 0)
  1071.       return origin - j + 1;
  1072.     else
  1073.     { i = origin;
  1074.       k = 0;
  1075.       while (count > 0 && k <= done)
  1076.       { leave = 0;
  1077.         j = MAXINSTLEN;
  1078.         while (!leave && j > 1)
  1079.           if (j + k <= done && next[j + k] == i)
  1080.             leave = 1;
  1081.           else
  1082.             j--;
  1083.         if (!leave)
  1084.           i--, k++;
  1085.         else
  1086.           i -= j, k += j;
  1087.         count--;
  1088. /* -------------------------------------------------------------------
  1089.    - If there is a source line, that also counts toward the number of lines
  1090.    ------------------------------------------------------------------- */
  1091.         source = unassemble_source (i);
  1092.         if (source)
  1093.           count--;
  1094.       }      
  1095.       return i;
  1096.     }
  1097.   }
  1098. }
  1099. /* ---------------------------------------------------------------------- */
  1100. static void
  1101. code_pane_goto (word32 v)
  1102. { int i = 0;
  1103.  
  1104.   if (v >= code_dump_origin && v <= code_dump_last)
  1105.   { while (code_pane_pos[i] < v)
  1106.       i++;
  1107.     if (code_pane_pos [i] == code_pane_pos[i+1])
  1108.       i++;
  1109.   } else
  1110.   { code_dump_origin = v;
  1111.     if (valid_instaddr (v) && unassemble_source (v))
  1112.       i++;
  1113.   }
  1114.   if (pane == 0)
  1115.     pane_pos = i;
  1116.   else
  1117.     pane_positions[0] = i;
  1118. }
  1119. /* ---------------------------------------------------------------------- */
  1120. inline static void
  1121. go (int bp)
  1122. { 
  1123. /* ------------------------------------------------------------
  1124.    - These modifications cannot be undone after run/trace/step 
  1125.    ------------------------------------------------------------ */
  1126.   reinit_undo (&data_undo);
  1127.   reinit_undo (®ister_undo);
  1128.   reinit_undo (&npx_undo);
  1129.   if (bp) 
  1130.     activate_breakpoints ();
  1131.   is_in_running_mode = 1;
  1132.   run_child ();
  1133.   is_in_running_mode = 0;
  1134.   if (bp)
  1135.     deactivate_breakpoints ();
  1136. }
  1137. /* ---------------------------------------------------------------------- */
  1138. static void
  1139. trace_over_bp (void)
  1140. { int len;
  1141.   char *inst;
  1142.   word32 old_addr = a_tss.tss_eip;
  1143.  
  1144.   inst = unassemble_proper (old_addr, &len);
  1145.   if (strcmp (inst, "popf") == 0 || strcmp (inst, "pushf") == 0)
  1146.   { edi.dr[7] = 0;
  1147.     edi.dr[7] |= ((BP_Code << 16) | 2);
  1148.     edi.dr[0] = old_addr + len + edi.app_base;
  1149.     edi.dr[7] |= 0x00000300L;
  1150.  
  1151.     is_in_running_mode = 1;
  1152.     run_child ();
  1153.     is_in_running_mode = 0;
  1154.   } else
  1155.   { a_tss.tss_eflags |= 0x0100;
  1156.     edi.dr[7] = 0;
  1157.     is_in_running_mode = 1;
  1158.     run_child ();
  1159.     is_in_running_mode = 0;
  1160.     a_tss.tss_eflags &= ~0x0100;
  1161.   }
  1162. }
  1163. /* ---------------------------------------------------------------------- */
  1164. static char condition[200];
  1165. /* ---------------------------------------------------------------------- */
  1166. static void
  1167. go_til_true_stop (int *terminated, int *int03hit)
  1168. { int b, i, keep_going = 1;
  1169.  
  1170.   while (keep_going)
  1171.   { go (1);
  1172.     i = a_tss.tss_irqn;
  1173.     *terminated = (i == 0x21) && (a_tss.tss_eax & 0xff00) == 0x4c00;
  1174.     *int03hit = (i == 0x03) &&
  1175.                 (get_breakpoint (BP_Code, -1, a_tss.tss_eip - 1) != -1);
  1176.     if (*terminated)
  1177.       a_tss.tss_eip -= 2;  /* point back to Int 21h */
  1178.     else if (*int03hit)
  1179.       a_tss.tss_eip--;     /* point back to Int 3 */
  1180.     if (*terminated)
  1181.       return;                           
  1182.  
  1183.     if (i == 1 || *int03hit)
  1184.     { int no;
  1185.   
  1186.       no = -1;
  1187.       for (b = 0; no == -1 && b <= 3; b++)
  1188.         if ((edi.dr[6] & (1 << b)) && (edi.dr[7] & (3 << (b * 2))))
  1189.           no = b;
  1190.       if (no != -1)
  1191.       { b = no;
  1192.         no = get_breakpoint ((edi.dr[7] >> (16 + 4 * no)) & 3,
  1193.                              ((edi.dr[7] >> (18 + 4 * no)) & 3) + 1,
  1194.                              edi.dr[no] - edi.app_base);
  1195.         if (no == -1)
  1196.         { no = b;
  1197.           no = get_breakpoint ((edi.dr[7] >> (16 + 4 * no)) & 3,
  1198.                                -1, edi.dr[no] - edi.app_base);
  1199.         }
  1200.       }
  1201.       else if (*int03hit)
  1202.         no = get_breakpoint (BP_Code, -1, a_tss.tss_eip);
  1203.       if (no != -1)
  1204.       { switch (breakpoint_table[no].sub_type)
  1205.         { case 1:                      /* Count down */
  1206.             if (breakpoint_table[no].count)
  1207.               breakpoint_table[no].count--;
  1208.             else
  1209.               keep_going = 0;
  1210.             break;
  1211.           case 2:                      /* Conditional */
  1212.           { int ofs, satisfy;
  1213.  
  1214.             strcpy (condition, breakpoint_table[no].condition);
  1215.             satisfy = parse_expression(breakpoint_table[no].length, 
  1216.                                        condition, &ofs);
  1217.             if (ofs != ParseError_ok)
  1218.               break;
  1219.             if (satisfy != 0)
  1220.               keep_going = 0;
  1221.             break;
  1222.           }
  1223.           default:
  1224.             keep_going = 0;
  1225.         }
  1226.         if (keep_going)
  1227.           trace_over_bp ();
  1228.       } else
  1229.         keep_going = 0;
  1230.     } else
  1231.       keep_going = 0;
  1232.   }
  1233. }
  1234. /* ---------------------------------------------------------------------- */
  1235. static void
  1236. step_over (int *terminated, int *int03hit, int len)
  1237. { int b, has_break_point = 0;
  1238.   word32 old_addr = 0;
  1239.   int sub_type = 0, count = 0;
  1240.   char *cond = 0;
  1241.  
  1242.   b = get_breakpoint (BP_Code, -1, a_tss.tss_eip);
  1243.   if (b != -1)
  1244.   { old_addr  = breakpoint_table[b].addr;
  1245.     sub_type  = breakpoint_table[b].sub_type;
  1246.     count     = breakpoint_table[b].count;
  1247.     cond      = strdup (breakpoint_table[b].condition);
  1248.     reset_breakpoint (b);
  1249.     has_break_point = 1;
  1250.   }
  1251.   b = set_breakpoint (BP_Code, 0, a_tss.tss_eip + len);
  1252.   go_til_true_stop (terminated, int03hit);
  1253.   reset_breakpoint (b);
  1254.   if (has_break_point)
  1255.   { b = set_breakpoint (BP_Code, 0, old_addr);
  1256.     breakpoint_table[b].sub_type = sub_type;
  1257.     breakpoint_table[b].count    = count;
  1258.     strcpy(breakpoint_table[b].condition, cond);
  1259.     free (cond);
  1260.   }
  1261. }
  1262. /* ---------------------------------------------------------------------- */
  1263. static void
  1264. step (int kind)
  1265. { int i, b, len, terminated = 0, int03hit = 0, refmem;
  1266.   char *inst = 0;
  1267.  
  1268.   switch (kind)
  1269.   { case 0:
  1270.       inst = unassemble_proper (a_tss.tss_eip, &len);
  1271.       if (strcmp (inst, "popf") == 0 || strcmp (inst, "pushf") == 0)
  1272.     kind = 1;  /* Push the right value of eflags (no trace flag).  */
  1273.       break;
  1274.     case 1:
  1275.       if (first_step)
  1276.     kind = 3;
  1277.       else
  1278.       { inst = unassemble_proper (a_tss.tss_eip, &len);
  1279.         if (strncmp (inst, "loop", 4)
  1280.             && strncmp (inst, "call", 4)
  1281.             && strncmp (inst, "int", 3) )
  1282.           kind = 0;
  1283.         break;
  1284.       }
  1285.   }
  1286.   switch (kind)
  1287.   { case 0: /* "Trace" */
  1288.       a_tss.tss_eflags |= 0x0100;
  1289.       edi.dr[7] = 0;
  1290.       refmem = strchr (inst, '[') != 0;
  1291.       if (refmem)
  1292.     /* Assume that all access to code and stack segments are safe.
  1293.        This should hold unless you do something extra-ordinary dirty.  */
  1294.     if (((a_tss.tss_ds == a_tss.tss_cs) || (a_tss.tss_ds == a_tss.tss_ss))
  1295.          && ((a_tss.tss_es == a_tss.tss_cs) || (a_tss.tss_es == a_tss.tss_ss))
  1296.          && ((a_tss.tss_fs == a_tss.tss_cs) || (a_tss.tss_fs == a_tss.tss_ss)
  1297.             || (strstr (inst, "fs:") == 0))
  1298.          && ((a_tss.tss_gs == a_tss.tss_cs) || (a_tss.tss_gs == a_tss.tss_ss)
  1299.             || (strstr (inst, "gs:") == 0)))
  1300.       refmem = 0;
  1301.       if (refmem)
  1302.     user_screen ();
  1303.       go (0);
  1304.       a_tss.tss_eflags &= ~0x0100;
  1305.       break;
  1306.     case 1: /* "Step Over" */
  1307.       user_screen ();
  1308.       step_over (&terminated, &int03hit, len);
  1309.       break;
  1310.     case 2: /* "Run" */
  1311.       user_screen ();
  1312.       if (get_breakpoint (BP_Code, -1, a_tss.tss_eip) != -1)
  1313.         trace_over_bp ();
  1314.       go_til_true_stop (&terminated, &int03hit);
  1315.       break;
  1316.     case 3: /* "Run to '_main'" */
  1317.       b = set_breakpoint (BP_Code, 0, main_entry);
  1318.       user_screen ();
  1319.       go_til_true_stop (&terminated, &int03hit);
  1320.       reset_breakpoint (b);
  1321.       break;
  1322.   }
  1323.   a_tss.tss_eflags &= ~0x0100;  /* Clear TF, in case it's set by Ctrl-C */
  1324.                 /* (in remote debugging.)               */
  1325.   code_pane_goto (a_tss.tss_eip);
  1326.   debug_screen ();
  1327.   if (kind)
  1328.     re_start_transfer ();
  1329.   redraw (0);
  1330.   first_step = 0;
  1331.   i = a_tss.tss_irqn;
  1332.  
  1333.   if (terminated)
  1334.   { message (CL_Msg, "Program terminated normally, exit code is %d",
  1335.         (word8)a_tss.tss_eax);
  1336.   } else 
  1337.   if (i == 1 || int03hit)
  1338.   { int no;
  1339.  
  1340.     no = -1;
  1341.     for (b = 0; no == -1 && b <= 3; b++)
  1342.       if ((edi.dr[6] & (1 << b)) && (edi.dr[7] & (3 << (b * 2))))
  1343.         no = b;
  1344.     if (no != -1)
  1345.       no = get_breakpoint ((edi.dr[7] >> (16 + 4 * no)) & 3,
  1346.                            ((edi.dr[7] >> (18 + 4 * no)) & 3) + 1,
  1347.                            edi.dr[no] - edi.app_base);
  1348.     else if (int03hit)
  1349.       no = get_breakpoint (BP_Code, -1, a_tss.tss_eip);
  1350.     if (no == -1)
  1351.       if (i == 1)
  1352.         no = get_breakpoint(BP_Code, -1, a_tss.tss_eip);
  1353.     if ((no != -1) && (kind > 0))
  1354.     { message (CL_Info, "%s %s breakpoint at %08lx triggered.",
  1355.                (breakpoint_table[no].sub_type == 0) ? "Normal" :
  1356.                 ((breakpoint_table[no].sub_type == 1) ? "Count-down" :
  1357.                  "Conditional"),
  1358.                (breakpoint_table[no].type == BP_Code) ? "code" :
  1359.                 ((breakpoint_table[no].type == BP_Write) ? "data write" :
  1360.                  "data read/write"),
  1361.                breakpoint_table[no].addr);
  1362.     }
  1363.   } else 
  1364.   { if (i == 0x79)
  1365.       message (CL_Info, "Keyboard interrupt");
  1366.     else if (i == 0x09)
  1367.       message (CL_Info, "Ctrl-C pressed (exception 0x09)");
  1368.     else if (i == 0x75)
  1369.     { char *reason;
  1370.     
  1371.       save_npx ();
  1372.       if ((npx.status & 0x0241) == 0x0241)
  1373.         reason = "stack overflow";
  1374.       else if ((npx.status & 0x0241) == 0x0041)
  1375.         reason = "stack underflow";
  1376.       else if (npx.status & 1)
  1377.         reason = "invalid operation";
  1378.       else if (npx.status & 2)
  1379.         reason = "denormal operand";
  1380.       else if (npx.status & 4)
  1381.         reason = "divide by zero";
  1382.       else if (npx.status & 8)
  1383.         reason = "overflow";
  1384.       else if (npx.status & 16)
  1385.         reason = "underflow";
  1386.       else if (npx.status & 32)
  1387.         reason = "loss of precision";
  1388.       else
  1389.         reason = "?";
  1390.       message (CL_Error,
  1391.         "Numeric Exception (%s) at eip=0x%08lx", reason, npx.eip);
  1392.       load_npx ();
  1393.     }
  1394.     else if (i == 8 || (i >= 10 && i <= 14))
  1395.       message (CL_Error, "Exception %d (0x%02x) occurred, error code=%#lx",
  1396.                i, i, a_tss.tss_error);
  1397.     else
  1398.       message (CL_Error, "Exception %d (0x%02x) occurred", i, i);
  1399.   }
  1400. }
  1401. /* ---------------------------------------------------------------------- */
  1402. static void
  1403. draw_debug_frames (void)
  1404. { frame (0, 1, main_x1, toplines + 1, active_pane_name);
  1405.   frame (main_x2, 1, cols - 1, toplines + 1, 0);
  1406.   frame (main_x1, 1, main_x2, toplines + 1, 0);
  1407.   frame (main_x3, toplines + 1, cols - 1, rows - 2, 0);
  1408.   frame (0, toplines + 1, main_x3, rows - 2, 0);
  1409.  
  1410.   if (!using_com_port_num)
  1411.   { put (main_x2, 1, "┬");
  1412.     put (main_x2, toplines + 1, "â”´");
  1413.     put (0, toplines + 1, "├");
  1414.     put (cols - 1, toplines + 1, "┤");
  1415.     put (main_x1, 1, "┬");
  1416.     put (main_x1, toplines + 1, "â”´");
  1417.     put (main_x3, toplines + 1, "┬");
  1418.     put (main_x3, rows - 2, "â”´");
  1419.   }
  1420. }
  1421. /* ---------------------------------------------------------------------- */
  1422. static void
  1423. draw_focused_frame (void)
  1424. { int x1, x2, y1, y2;
  1425.  
  1426.   screen_attr = screen_attr_ffocus;
  1427.   switch (pane)    /* Set focused pane */
  1428.   { case 1:        /* Top middle */
  1429.       x1 = main_x1;
  1430.       x2 = main_x2;
  1431.       y1 = 1;
  1432.       y2 = toplines + 1;
  1433.       break;
  1434.     case 2:        /* Top right */
  1435.       x1 = main_x2;
  1436.       x2 = cols - 1;
  1437.       y1 = 1;
  1438.       y2 = toplines + 1;
  1439.       break;
  1440.      case 3:        /* Bottom right */
  1441.       x1 = main_x3;
  1442.       x2 = cols - 1;
  1443.       y1 = toplines + 1;
  1444.       y2 = rows - 2;
  1445.       break;
  1446.      case 4:        /* Bottom left */
  1447.       x1 = 0;
  1448.       x2 = main_x3;
  1449.       y1 = toplines + 1;
  1450.       y2 = rows - 2;
  1451.       break;
  1452.     default:       /* Top left */
  1453.       x1 = 0;
  1454.       x2 = main_x1;
  1455.       y1 = 1;
  1456.       y2 = toplines + 1;
  1457.       break;
  1458.   }
  1459.   if (pane < 1 || pane > 4)
  1460.     double_frame (x1, y1, x2, y2, active_pane_name);
  1461.   else
  1462.     double_frame (x1, y1, x2, y2, 0);
  1463.   screen_attr = screen_attr_normal;
  1464. }          
  1465. /* ---------------------------------------------------------------------- */
  1466. static void
  1467. put_redraw (int x, int y, int width, int max_y, int offset, char *buf)
  1468. { int buflen;
  1469.   buflen = strlen (buf);
  1470.   if (y <= max_y)
  1471.     putl (x, y, width, buf + ((offset < buflen) ? offset : buflen));
  1472. }
  1473. /* ---------------------------------------------------------------------- */
  1474. void
  1475. redraw_registers (char *buf)
  1476. { int reg, x = main_x1 + 1, y = 2, width = main_x2 - main_x1 - 1;
  1477.  
  1478.   for (reg = reg_pane_origin; regs_type[reg]; reg++)
  1479.   { if (regs_type[reg] == 's')
  1480.       sprintf (buf, " %s %04x",  regs_names[reg],
  1481.                *(unsigned short *)(regs_addr[reg]));
  1482.     else
  1483.       sprintf (buf, "%s %08lx", regs_names[reg], *(regs_addr[reg]));     
  1484.     put_redraw (x, y++, width, toplines,
  1485.                 pane_offset[REGISTER_PANE_NUM], buf);
  1486.     if (y > toplines)
  1487.       break;
  1488.   }
  1489.   while (y <= toplines)
  1490.     putl (x, y++, width, " ");
  1491.   if (pane == REGISTER_PANE_NUM)
  1492.   { screen_attr = screen_attr_focus;
  1493.     if (pane_pos >= toplines - 1)
  1494.       pane_pos = toplines - 2;
  1495.     highlight (main_x1 + 1, pane_pos + 2,
  1496.                main_x2 - main_x1 - 1);
  1497.     screen_attr = screen_attr_normal;
  1498.   }
  1499. }
  1500. /* ---------------------------------------------------------------------- */
  1501. void
  1502. redraw_flags (char *buf)
  1503. { int f, x = main_x2 + 1, y = 2, width = cols - main_x2 - 2;
  1504.   static char flags[] = "c?p?a?zn?ido????";
  1505.  
  1506.   for (f = flag_pane_origin; flags[f]; f++)
  1507.   { if (flags[f] != '?')
  1508.     { sprintf (buf, "%c=%d", flags[f], (int)((a_tss.tss_eflags >> f) & 1));
  1509.       put_redraw (x, y++, width, toplines, pane_offset[FLAG_PANE_NUM], buf);
  1510.     }
  1511.     if (y > toplines)
  1512.       break;
  1513.   }
  1514.   while (y <= toplines)
  1515.     putl (x, y++, width, " ");
  1516.   if (pane == FLAG_PANE_NUM)
  1517.   { screen_attr = screen_attr_focus;
  1518.     if (pane_pos >= toplines - 1)
  1519.       pane_pos = toplines - 2;
  1520.     highlight (main_x2 + 1, pane_pos + 2,
  1521.                cols - main_x2 - 2);
  1522.     screen_attr = screen_attr_normal;
  1523.   }
  1524. }
  1525. /* ---------------------------------------------------------------------- */
  1526. void
  1527. redraw_breakpoints (char *buf)
  1528. { int b, x = main_x3 + 1, y = toplines + 2, width = cols - main_x3 - 2;
  1529.   char *name;
  1530.   int32 delta;
  1531.  
  1532.   for (b = breakpoint_origin;
  1533.        b < breakpoint_origin + bottomlines / 2 && b < breakpoint_count;
  1534.        b++)
  1535.   { switch (breakpoint_table[b].type)
  1536.     { case BP_Code:
  1537.         sprintf (buf, "%-20s", "C ");
  1538.         break;
  1539.       case BP_Write:
  1540.         sprintf (buf, "%-20s, %d","DW",
  1541.                  breakpoint_table[b].length);
  1542.         break;
  1543.       case BP_Read:
  1544.         sprintf (buf, "%-20s, %d","DR",
  1545.                  breakpoint_table[b].length);
  1546.         break;
  1547.     }    
  1548.     switch (breakpoint_table[b].sub_type)
  1549.     { case 0:
  1550.         sprintf (buf + 3, "Norm.");
  1551.         break;
  1552.       case 1:
  1553.         sprintf (buf + 3, "Count");
  1554.         break;
  1555.       case 2:
  1556.         sprintf (buf + 3, "Cond.");
  1557.         break;
  1558.     }
  1559.     buf[8] = ' ';
  1560.     putl (x, y, width, buf);
  1561.     screen_attr = screen_attr_addr;
  1562.     sprintf(buf, "%08lx", breakpoint_table[b].addr);
  1563.     if (width > 12)
  1564.       putl(x + 12, y, width - 12 > 8 ? 8 : width - 12, buf);
  1565.     y++;
  1566.     screen_attr = screen_attr_normal;
  1567.     name = syms_val2name (breakpoint_table[b].addr, &delta);
  1568.     if (name[0] != '0')
  1569.       if (delta && strlen (name) < width)
  1570.         sprintf (buf, " %s+%#lx", name, delta);
  1571.       else
  1572.         sprintf (buf, " %-*s", width, name);
  1573.     else
  1574.       buf[0] = '\0';      
  1575.     put_redraw (x, y++, width, rows,
  1576.                 pane_offset[BREAKPOINT_PANE_NUM], buf);
  1577.   }
  1578.   if (breakpoint_count == 0)
  1579.     putl (x, y++, width, "No breakpoints");
  1580.   while (y < rows - 2)
  1581.     putl (x, y++, width, "");
  1582.   if (pane == BREAKPOINT_PANE_NUM)
  1583.   { screen_attr = screen_attr_focus;
  1584.     if (breakpoint_origin >= breakpoint_count)
  1585.       breakpoint_origin = breakpoint_count ? breakpoint_count - 1 : 0;
  1586.     if (breakpoint_origin + pane_pos >= breakpoint_count)
  1587.       pane_pos = breakpoint_count - breakpoint_origin;
  1588.     if (2 * pane_pos + 2 > bottomlines)
  1589.       pane_pos = bottomlines / 2 - 1;
  1590.     if (pane_pos < 0)
  1591.       pane_pos = 0;
  1592.     else
  1593.     { highlight (main_x3 + 1, toplines + 2 + 2 * pane_pos, 
  1594.                  cols - main_x3 - 2);
  1595.       if (2 * pane_pos + 1 < bottomlines)
  1596.         highlight (main_x3 + 1, toplines + 3 + 2 * pane_pos,
  1597.                    cols - main_x3 - 2);
  1598.     }
  1599.     screen_attr = screen_attr_normal;
  1600.   }
  1601. }
  1602. /* ---------------------------------------------------------------------- */
  1603. void
  1604. redraw_data (char *buf)
  1605. { word32 p = data_dump_origin;
  1606.   int b, x, y = toplines + 2, ok, width = main_x3 - 1;
  1607.   unsigned char data[8], xpos[8];
  1608.   int buflen;
  1609.  
  1610.   for (x = 0; x < 8; x++)
  1611.     xpos[x] = 1 + ((data_dump_size == 1) ? (x * 3) :
  1612.         ((data_dump_size == 2) ? ((x / 2) * 5 + (~x & 1) * 2) :
  1613.          ((x / 4) * 9 + (~x & 3) * 2)));
  1614.   while (y < rows - 2)
  1615.   { if ((ok = valid_addr (p, 8)))
  1616.       read_child (p, data, 8);
  1617.  
  1618.     screen_attr = screen_attr_addr;
  1619.     sprintf (buf, "%08lx:",p);
  1620.     putl (1, y, 9, buf);
  1621.     sprintf (buf, "%70s", " ");
  1622.     for (x = 0; x < 8; x++)
  1623.       if (ok || valid_addr (p + x, 1))
  1624.       { if (!ok) 
  1625.           read_child (p + x, data + x, 1);
  1626.         buf[xpos[x]] = hexchars[data[x] >> 4];
  1627.         buf[xpos[x] + 1] = hexchars[data[x] & 0xf];
  1628.         buf[28 + x] = (data[x] ? data[x] : '.');
  1629.       } else
  1630.         buf[xpos[x]] = buf[xpos[x + 1]] = buf[28 + x] = '?';
  1631.     screen_attr = screen_attr_normal;                                   
  1632.     buflen = strlen (buf);
  1633.     putl (10, y, width - 9, buf + ((pane_offset[DATA_PANE_NUM] < buflen)
  1634.                                   ? pane_offset[DATA_PANE_NUM] : buflen));
  1635.     screen_attr = screen_attr_break;
  1636.     for (x = 0; x < 8; x++)
  1637.       for (b = 0; b < breakpoint_count; b++)
  1638.         if (breakpoint_table[b].type != BP_Code
  1639.             && p + x >= breakpoint_table[b].addr
  1640.             && p + x < (breakpoint_table[b].addr
  1641.                       + breakpoint_table[b].length))
  1642.            { if (xpos[x] >= pane_offset[DATA_PANE_NUM])
  1643.                highlight (xpos[x] + 10 - pane_offset[DATA_PANE_NUM], y, 2);
  1644.              if (x + 28 >= pane_offset[DATA_PANE_NUM])
  1645.                highlight (38 + x - pane_offset[DATA_PANE_NUM], y, 1);
  1646.            }
  1647.     screen_attr = screen_attr_normal;
  1648.     p += 8;
  1649.     y++;
  1650.   }
  1651.   data_dump_last = p - 1;
  1652.   if (pane == DATA_PANE_NUM)
  1653.   { int offset;
  1654.     int x = pane_pos & 7, y = pane_pos >> 3;
  1655.  
  1656.     while (y >= bottomlines)
  1657.     { y--;
  1658.       pane_pos -= 8;
  1659.     }
  1660.     screen_attr = screen_attr_focus;
  1661.     if ((38 + x + data_dump_size <= main_x3) &&
  1662.        (x + 28 >= pane_offset[INFO_PANE_NUM]))
  1663.        highlight (38 + x - pane_offset[DATA_PANE_NUM], 
  1664.                   toplines + 2 + y, data_dump_size);
  1665.     switch (data_dump_size)
  1666.     { case 1:  
  1667.         offset = 1 + 3 * x - pane_offset[DATA_PANE_NUM];
  1668.         if (13 + 3 * x <= main_x3)
  1669.           if (offset >= 0)
  1670.             highlight (11 + 3 * x - pane_offset[DATA_PANE_NUM], 
  1671.                        toplines + 2 + y, 2);
  1672.           else if (offset > -1)
  1673.             highlight (10, toplines + 2 + y, 2 + offset);
  1674.         break;
  1675.       case 2:
  1676.         offset = 1 + 5 * (x >> 1) - pane_offset[DATA_PANE_NUM];
  1677.         if (15 + 5 * (x >> 1) <= main_x3)
  1678.           if (offset >= 0)
  1679.             highlight (11 + 5 * (x >> 1) - pane_offset[DATA_PANE_NUM], 
  1680.                        toplines + 2 + y, 4);
  1681.           else if (offset > -4)
  1682.             highlight (10, toplines + 2 + y, 4 + offset);
  1683.         break;
  1684.       case 4:
  1685.         offset = 1 + 9 * (x >> 2) - pane_offset[DATA_PANE_NUM];
  1686.         if (19 + 9 * (x >> 2) <= main_x3)
  1687.           if (offset >= 0)
  1688.             highlight (11 + 9 * (x >> 2) - pane_offset[DATA_PANE_NUM], 
  1689.                        toplines + 2 + y, 8);
  1690.           else if (offset > -8)
  1691.             highlight (10, toplines + 2 + y, 8 + offset);
  1692.         break;
  1693.     }
  1694.     screen_attr = screen_attr_normal;
  1695.   }
  1696. }
  1697. /* ---------------------------------------------------------------------- */
  1698. void
  1699. redraw_code (char *buf)
  1700. { word32 p = code_dump_origin, width = main_x1 - 1;
  1701.   int y = 2, len, source = 0, buflen;
  1702.   char *txt;
  1703.  
  1704.   while (y <= toplines)
  1705.   { source = !source;
  1706.     code_pane_pos[y - 2] = p;
  1707.     if (source)
  1708.     { txt = unassemble_source (p);
  1709.       if (txt)
  1710.       { screen_attr = screen_attr_source;
  1711.         buflen = strlen (txt);
  1712.         putl (1, y++, width, txt + ((pane_offset[CODE_PANE_NUM] < buflen)
  1713.                                    ? pane_offset[CODE_PANE_NUM] : buflen));
  1714.       }
  1715.     }    else
  1716.     { int temp_len;
  1717.  
  1718.       if (valid_instaddr (p))
  1719.         txt = unassemble_proper (p, &len);
  1720.       else
  1721.         txt = "?", len = 1;
  1722.       sprintf (buf, "%08lx%c", p, p == a_tss.tss_eip ? '>' : ' ');
  1723.       screen_attr = (get_breakpoint (BP_Code, -1, p) == -1
  1724.                     ? screen_attr_addr : screen_attr_break);
  1725.       temp_len = strlen(buf);
  1726.       putl (1, y++, (width > temp_len ? temp_len : width), buf);
  1727.       if (width > temp_len)
  1728.       { screen_attr = (get_breakpoint (BP_Code, -1, p) == -1
  1729.                       ? screen_attr_asm : screen_attr_break);
  1730.         buflen = strlen (txt);
  1731.         putl(temp_len + 1,y - 1,(width - temp_len),
  1732.              txt + ((pane_offset[CODE_PANE_NUM] < buflen)
  1733.                    ? pane_offset[CODE_PANE_NUM] : buflen));
  1734.       }
  1735.       p += len;
  1736.     }
  1737.   }
  1738.   code_pane_pos[y - 2] = p + 1;
  1739.   code_dump_last = p - 1;
  1740.   if (pane == CODE_PANE_NUM)
  1741.   { screen_attr = screen_attr_focus;
  1742.     if (pane_pos >= toplines - 1)
  1743.       pane_pos = toplines - 2;
  1744.     highlight (1, pane_pos + 2, main_x1 - 1);
  1745.   }
  1746.   screen_attr = screen_attr_normal;
  1747. }
  1748. /* ---------------------------------------------------------------------- */
  1749. void
  1750. redraw_npx (char *buf)
  1751. { int i, y = 2, width = main_x1 - 1;
  1752.   static char *rtype[] = { "Near", "-Inf", "+Inf", "Zero" };
  1753.  
  1754.   save_npx ();
  1755.   sprintf (buf,
  1756.            "Control: %04lx PR=%s UN=%s OV=%s ZD=%s DN=%s IV=%s Rnd=%s",
  1757.            npx.control & 0xffff,
  1758.            (npx.control & (1 << 5)) ? "N" : "Y",
  1759.            (npx.control & (1 << 4)) ? "N" : "Y",
  1760.            (npx.control & (1 << 3)) ? "N" : "Y",
  1761.            (npx.control & (1 << 2)) ? "N" : "Y",
  1762.            (npx.control & (1 << 1)) ? "N" : "Y",
  1763.            (npx.control & (1 << 0)) ? "N" : "Y",
  1764.            rtype[(npx.control >> 10) & 3]);
  1765.   put_redraw (1, y++, width, toplines, pane_offset[NPX_PANE_NUM], buf);
  1766.   sprintf (buf,
  1767.            "Status:  %04lx PR=%s UN=%s OV=%s ZD=%s DN=%s IV=%s ST=%s",
  1768.            npx.status & 0xffff,
  1769.            (npx.status & (1 << 5)) ? "Y" : "N",
  1770.            (npx.status & (1 << 4)) ? "Y" : "N",
  1771.            (npx.status & (1 << 3)) ? "Y" : "N",
  1772.            (npx.status & (1 << 2)) ? "Y" : "N",
  1773.            (npx.status & (1 << 1)) ? "Y" : "N",
  1774.            (npx.status & (1 << 0)) ? "Y" : "N",
  1775.            (npx.status & (1 << 6)) ? "Y" : "N");
  1776.   put_redraw (1, y++, width, toplines, pane_offset[NPX_PANE_NUM], buf);
  1777.   sprintf (buf, "%19sC3=%d C2=%d C1=%d C0=%d",
  1778.            "",
  1779.            (npx.status & (1 << 14)) != 0,
  1780.            (npx.status & (1 << 10)) != 0,
  1781.            (npx.status & (1 <<  9)) != 0,
  1782.            (npx.status & (1 <<  8)) != 0);
  1783.   put_redraw (1, y++, width, toplines, pane_offset[NPX_PANE_NUM], buf);
  1784.   for (i = 0; i < 8; i++)
  1785.   {
  1786. /* ---------------------------------------------------------------------
  1787.    -     We assume that `long double' is the same type as npx.reg[i].
  1788.    -     It would be sensible to check that the sizes match, but they
  1789.    -     don't!  For alignment reasons, `sizeof (long double)' is 12.  
  1790.    ---------------------------------------------------------------------*/
  1791.       long double d;
  1792.       int tag;
  1793.       int tos = (npx.status >> 11) & 7;
  1794.       int exp = (int)npx.reg[i].exponent - 16382;
  1795.       char *dstr = alloca (30);
  1796.  
  1797.       dstr[0] = (npx.reg[i].sign) ? '-' : '+';
  1798.       dstr[1] = '\0';
  1799.       tag = (npx.tag >> (((i + tos) & 7) * 2)) & 3;
  1800.       switch (tag)
  1801.       { case 0:
  1802.           if (abs (exp) < 1000)
  1803.           { d = *((long double*)(npx.reg + i));
  1804. /* --------------------------------------------------------------------
  1805.    -  sprintf does not (djgpp 1.11m3) handle long doubles.  
  1806.    -------------------------------------------------------------------- */
  1807.             sprintf(dstr,"%+.16g", (double) d);
  1808.           } else
  1809.             sprintf (dstr, "Valid, %s, and %s",
  1810.                      npx.reg[i].sign ? "negative" : "positive",
  1811.                      exp > 0 ? "huge" : "tiny");
  1812.           break;
  1813.         case 1:
  1814.           strcat (dstr, "Zero");
  1815.           break;
  1816.         case 2:
  1817.           if (npx.reg[i].exponent == 0x7fff)
  1818.             if (npx.reg[i].sig3 == 0x8000 && npx.reg[i].sig2 == 0x0000
  1819.               && npx.reg[i].sig1 == 0x0000  && npx.reg[i].sig0 == 0x0000)
  1820.               strcat (dstr, "Inf");
  1821.             else
  1822.               strcat (dstr, "NaN");
  1823.           else
  1824.             sprintf (dstr, "Special");
  1825.           break;
  1826.         case 3:
  1827.           sprintf (dstr, "Empty");
  1828.           break;
  1829.       }
  1830.       sprintf (buf, "st(%d): %d %04x %04x%04x%04x%04x %s",
  1831.                i,
  1832.                npx.reg[i].sign, npx.reg[i].exponent,
  1833.                npx.reg[i].sig3, npx.reg[i].sig2,
  1834.                npx.reg[i].sig1, npx.reg[i].sig0,
  1835.                dstr);
  1836.       put_redraw (1, y++, width, toplines,
  1837.                   pane_offset[NPX_PANE_NUM], buf);
  1838.       if (y > toplines)
  1839.         break;
  1840.   }
  1841.   while (y <= toplines)
  1842.     putl (1, y++, width, " ");
  1843.   load_npx ();
  1844.   if (pane == NPX_PANE_NUM)
  1845.   { screen_attr = screen_attr_focus;
  1846.     if (pane_pos >= toplines - 1)
  1847.       pane_pos = toplines - 2;
  1848.     highlight (1, pane_pos + 2, main_x1 - 1);
  1849.     screen_attr = screen_attr_normal;
  1850.   }
  1851. }
  1852. /* ---------------------------------------------------------------------- */
  1853. void
  1854. redraw_stack (char *buf)
  1855. { int line, y = 2, no = -stack_dump_origin, width = main_x1 - 1;
  1856.   unsigned char eipcode[4];
  1857.   word32 delta, v = a_tss.tss_ebp;
  1858.   word32 vaddr = a_tss.tss_eip;
  1859.   int first = 1;
  1860.  
  1861.   stack_dump_more = 0;
  1862.   while (valid_instaddr (vaddr))
  1863.   { if (no++ >= 0)
  1864.       if (y >= toplines)
  1865.       { stack_dump_more = 1;
  1866.         break;
  1867.       } else
  1868.       { char *symaddr, *sourceaddr, *sourcefile;
  1869.         int len;
  1870.         char *mybuf;
  1871.         
  1872.         symaddr = syms_val2name (vaddr, &delta);
  1873.         sourcefile = syms_val2line (vaddr, &line, 0);
  1874.         if (sourcefile)
  1875.           sprintf (sourceaddr = alloca (cols + strlen (sourcefile)),
  1876.                    ", line %d in file %s", line, sourcefile);
  1877.         else if (delta)
  1878.           sprintf (sourceaddr = alloca (cols), "%+ld", (long) delta);
  1879.         else
  1880.           sourceaddr = "";
  1881.         len = 15 + strlen (symaddr) + strlen (sourceaddr);
  1882.         mybuf = alloca (len + 15);
  1883.         sprintf (mybuf, "%08lx: %s%s", vaddr, symaddr, sourceaddr);
  1884.         stack_dump_last = (y - 2) / 2;
  1885.         stack_dump_pos[stack_dump_last] = vaddr;
  1886.         put_redraw (1, y++, width, toplines,
  1887.                     pane_offset[STACK_PANE_NUM], mybuf);
  1888.         sprintf (mybuf, "   Stack frame: %08lx", v);
  1889.         put_redraw (1, y++, width, toplines,
  1890.                     pane_offset[STACK_PANE_NUM], mybuf);
  1891.       }
  1892.     if (first)
  1893.     { first = 0;
  1894.       read_child (vaddr, eipcode, 3);
  1895. /* ---------------------------------------------------------------------
  1896.    - We look directly at the bit pattern instead of using disassembly;
  1897.    - the bit patterns are those generated by gcc.  In general we
  1898.    - cannot expect to be able to follow a non-gcc stack anyway.  
  1899.    --------------------------------------------------------------------- */
  1900.       if ((eipcode[0] == 0x55 && eipcode[1] == 0x89 && eipcode[2] == 0xe5)
  1901.           || eipcode[0] == 0xc3)
  1902.       {
  1903. /* ---------------------------------------------------------------------
  1904.    - In this case where we are looking at `Push Ebp//Mov Ebp,Esp'
  1905.    - or `Ret', only the return address is on the stack; I believe
  1906.    - this only to happen in the innermost activation record.  
  1907.    --------------------------------------------------------------------- */
  1908.         if (valid_addr (a_tss.tss_esp, 4))
  1909.           read_child (a_tss.tss_esp, &vaddr, 4);
  1910.         else
  1911.           break;
  1912.       } else
  1913.       { if (eipcode[0] == 0x89 && eipcode[1] == 0xe5)
  1914. /* ---------------------------------------------------------------------
  1915.    - When looking at `Mov Esp,Ebp' the next stack frame is on
  1916.    - the stack and pointed to by the stack pointer.  We are
  1917.    - actually in the same situation after `Mov Esp,Ebp' which
  1918.    - is generated by gcc with the -m486 option.  This case is,
  1919.    - however, handled perfectly by using the base pointer.  
  1920.    --------------------------------------------------------------------- */
  1921.           v = a_tss.tss_esp;
  1922.         if (v >= a_tss.tss_esp && v < 0x80000000L && valid_addr (v, 8))
  1923.         { read_child (v + 4, &vaddr, 4);
  1924.           read_child (v, &v, 4);
  1925.         } else
  1926.           break;
  1927.       }
  1928.     } else
  1929.     { if (v >= a_tss.tss_esp && v < 0x80000000L && valid_addr (v, 8))
  1930.       { read_child (v + 4, &vaddr, 4);
  1931.         read_child (v, &v, 4);
  1932.       } else
  1933.         break;
  1934.     }
  1935.   }
  1936.   while (y <= toplines)
  1937.     putl (1, y++, width, " ");
  1938.   if (pane == STACK_PANE_NUM)
  1939.   { screen_attr = screen_attr_focus;
  1940.     if (pane_pos * 2 + 2 > toplines - 1)
  1941.       pane_pos = (toplines - 1) / 2 - 1;
  1942.     if (pane_pos < 0)
  1943.       pane_pos = 0;
  1944.     else
  1945.     { if (pane_pos > stack_dump_last)
  1946.         pane_pos = stack_dump_last;
  1947.       highlight (1, pane_pos * 2 + 2, main_x1 - 1);
  1948.     }
  1949.     screen_attr = screen_attr_normal;
  1950.   }
  1951. }
  1952. /* ---------------------------------------------------------------------- */
  1953. void
  1954. redraw_info (char *buf)
  1955. { int y = 2, width = main_x1 - 1;
  1956.   long ul;
  1957.   char *s = alloca (20);
  1958.   _go32_dpmi_meminfo info;
  1959.   _go32_dpmi_registers regs;
  1960.  
  1961.   sprintf (buf, "Debugger version ............: %d.%02d %s",
  1962.        MAJOR_VER, MINOR_VER,
  1963.        MAJOR_VER == 0 ? "beta" : "");
  1964.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  1965.   _go32_dpmi_get_free_memory_information (&info);
  1966.   switch (_go32_info_block.run_mode)
  1967.   { case _GO32_RUN_MODE_RAW:
  1968.       sprintf (s, "Raw");
  1969.       break;
  1970.     case _GO32_RUN_MODE_XMS:
  1971.       sprintf (s, "Xms");
  1972.       break;
  1973.     case _GO32_RUN_MODE_VCPI:
  1974.       sprintf (s, "Vcpi");
  1975.       break;
  1976.     case _GO32_RUN_MODE_DPMI:
  1977.       sprintf (s, "Dpmi %d.%02x",
  1978.            _go32_info_block.run_mode_info >> 8,
  1979.            _go32_info_block.run_mode_info & 0xff);
  1980.       break;
  1981.     default:
  1982.       sprintf (s, "Unknown");
  1983.   }
  1984.   sprintf (buf, "Running mode ................: %s", s);
  1985.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  1986.   if (y <= toplines)
  1987.     putl (1, y++, width, "");
  1988.  
  1989.   ul = info.total_physical_pages;
  1990.   if (ul > 0)
  1991.   { ul <<= 12;
  1992.     sprintf (buf, "Total physical memory .......: %lu KB", ul >> 10);
  1993.     put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  1994.   }
  1995.   ul = info.available_physical_pages
  1996.     ? info.available_physical_pages << 12
  1997.     : info.available_memory;
  1998.   sprintf (buf, "Remaining physical memory ...: %lu KB", ul >> 10);
  1999.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2000.   ul = info.available_memory;
  2001.   sprintf (buf, "Remaining virtual memory ....: %lu KB", ul >> 10);
  2002.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2003.   ul = info.free_linear_space << 12;
  2004.   if (ul >= 0)
  2005.   { sprintf (buf, "Free linear space ...........: %ld KB", ul >> 10);
  2006.     put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2007.   }
  2008. /* ----------------------------------------------------------------
  2009.    - Remember that Dos memory is only made available of direct request;
  2010.    - using 0xffff does not count as a request.  
  2011.    ---------------------------------------------------------------- */
  2012.   regs.h.ah = 0x48;
  2013.   regs.x.bx = 0xffff;
  2014.   regs.x.ss = regs.x.sp = 0;                        
  2015. /* ----------------------------------------------------------
  2016.    -  The call _go32_dpmi_simulate_int () causes the program 
  2017.    -  to hang under XMS mode.
  2018.    ---------------------------------------------------------- */
  2019.   if (_go32_info_block.run_mode != _GO32_RUN_MODE_XMS)
  2020.     _go32_dpmi_simulate_int (0x21, ®s);
  2021.   ul = regs.x.bx << 4;
  2022.   sprintf (buf, "Free dos memory .............: %ld %s",
  2023.            ul > 8192 ? ul >> 10 : ul,
  2024.            ul > 8192 ? "KB"     : "Bytes");
  2025.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2026.   if (y <= toplines)
  2027.     putl (1, y++, width, "");
  2028.   sprintf (buf, "Ctrl-C checking .............: %s",
  2029.           getcbrk () ? "On" : "Off");
  2030.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2031.   if (y <= toplines)
  2032.     putl (1, y++, width, "");
  2033.  
  2034.   sprintf (buf, "Program text ................: %08lx - %08lx",
  2035.            areas[A_text].first_addr, areas[A_text].last_addr);
  2036.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2037.   sprintf (buf, "Program data ................: %08lx - %08lx",
  2038.            areas[A_data].first_addr, areas[A_data].last_addr);
  2039.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2040.   sprintf (buf, "Program bss .................: %08lx - %08lx",
  2041.            areas[A_bss].first_addr, areas[A_bss].last_addr);
  2042.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2043.   sprintf (buf, "Program stack ...............: %08lx - %08lx",
  2044.            areas[A_stack].first_addr, areas[A_stack].last_addr);
  2045.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2046.   if (y <= toplines)
  2047.     putl (1, y++, width, "");
  2048.   sprintf (buf, "Using com port number .......: %d",
  2049.            using_com_port_num);
  2050.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2051.   sprintf (buf, "Using symbol file ...........: %s%s.%s",
  2052.            sympath, symname, symext);
  2053.   put_redraw (1, y++, width, toplines, pane_offset[INFO_PANE_NUM], buf);
  2054.   while (y <= toplines)
  2055.     putl (1, y++, width, " ");
  2056. }
  2057. /* ---------------------------------------------------------------------- */
  2058. void
  2059. redraw_whereis (char *buf)
  2060. { int y = 2, width = main_x1 - 1, i = whereis_origin;
  2061.   char *s;
  2062.  
  2063.   while (y <= toplines)
  2064.     if (i < whereis_sym_count)
  2065.     { s = syms_makewild (whereis_pane_sym[i++]);
  2066.       put_redraw (1, y++, width, toplines,
  2067.                   pane_offset[WHEREIS_PANE_NUM], s);
  2068.     } else
  2069.       putl (1, y++, width, " ");
  2070.   if (pane == WHEREIS_PANE_NUM)
  2071.   { screen_attr = screen_attr_focus;
  2072.     if (pane_pos >= toplines - 1)
  2073.       pane_pos = toplines - 2;
  2074.     if (whereis_sym_count)
  2075.       highlight (1, pane_pos + 2, main_x1 - 1);
  2076.     screen_attr = screen_attr_normal;
  2077.   }
  2078. }
  2079. /* ---------------------------------------------------------------------- */
  2080. void
  2081. redraw_module (char *buf)
  2082. { int y = 2, width = main_x1 - 1, i = module_origin;
  2083.  
  2084.   while (y <= toplines)
  2085.     if (i < module_text_count)
  2086.       put_redraw (1, y++, width, toplines,
  2087.                   pane_offset[MODULE_PANE_NUM], module_pane_text[i++]);
  2088.     else
  2089.       putl (1, y++, width, " ");
  2090.   if (pane == MODULE_PANE_NUM)
  2091.   { screen_attr = screen_attr_focus;
  2092.     if (pane_pos >= toplines - 1)
  2093.       pane_pos = toplines - 2;
  2094.     if (module_text_count)
  2095.       highlight (1, pane_pos + 2, main_x1 - 1);
  2096.     screen_attr = screen_attr_normal;
  2097.   }
  2098. }
  2099. /* ---------------------------------------------------------------------- */
  2100. void
  2101. redraw_help (char *buf)
  2102. { int y = 2, width = main_x1 - 1, i = help_origin;
  2103.  
  2104.   while (y <= toplines)
  2105.     if (i < help_text_count)
  2106.     { screen_attr = ((*help_pane_text[i] != ' ')
  2107.             ? screen_attr_help : screen_attr_normal);
  2108.       put_redraw (1, y++, width, toplines,
  2109.                   pane_offset[HELP_PANE_NUM], help_pane_text[i++]);
  2110.     } else
  2111.       putl (1, y++, width, " ");
  2112.   if (pane == HELP_PANE_NUM)
  2113.   { screen_attr = screen_attr_focus;
  2114.     if (pane_pos >= toplines - 1)
  2115.       pane_pos = toplines - 2;
  2116.     if (help_text_count)
  2117.       highlight (1, pane_pos + 2, main_x1 - 1);
  2118.     screen_attr = screen_attr_normal;
  2119.   }
  2120. }
  2121. /* --
  2122. static char *st_fmt = "%04x %04x %04x %04x %04x %04x %08lx %08lx";
  2123.  -- */
  2124. /* ---------------------------------------------------------------------- */
  2125. void
  2126. redraw (int first)
  2127. { char *buf = alloca (1024);
  2128.  
  2129.   debug_screen ();
  2130.   screen_attr = ScreenAttrib = screen_attr_normal;
  2131.   if (first == -1)
  2132.   { screen_attr = screen_attr_resize;
  2133.     clear_screen();
  2134.   }
  2135.   draw_debug_frames ();
  2136.   if (first == -1)           /* For resizing */
  2137.   { put_screen (debug_screen_save);
  2138.     return;
  2139.   }
  2140.   draw_focused_frame ();
  2141.  
  2142.   redraw_registers (buf);
  2143.   redraw_flags (buf);
  2144.   redraw_breakpoints (buf);
  2145.   redraw_data (buf);
  2146.   if (code_pane_active)
  2147.     redraw_code (buf);
  2148.   if (npx_pane_active)
  2149.     redraw_npx (buf);
  2150.   if (stack_pane_active)
  2151.     redraw_stack (buf);
  2152.   if (info_pane_active)
  2153.     redraw_info (buf);
  2154.   if (whereis_pane_active)
  2155.     redraw_whereis (buf);
  2156.   if (module_pane_active)
  2157.     redraw_module (buf);
  2158.   if (help_pane_active)
  2159.     redraw_help (buf);
  2160.   screen_attr = st_ln_attr;
  2161.  
  2162. /* --
  2163.  asm ("push %ebp         \n\
  2164.        push %esp         \n\
  2165.        push %ss          \n\
  2166.        push %gs          \n\
  2167.        push %fs          \n\
  2168.        push %es          \n\
  2169.        push %ds          \n\
  2170.        push %cs          \n\
  2171.        push _st_fmt      \n\
  2172.        push $_StatusLine \n\
  2173.        call _sprintf     \n\
  2174.        add  $0x28, %esp  \n\
  2175.       ");
  2176.   st_fmt[0] += 0;
  2177.  -- */
  2178.  
  2179.   putl (0, rows - 1, cols, StatusLine);
  2180.   if (running_xsupport)
  2181.     redraw_xsupport (buf);
  2182.   else
  2183.     show_menu_bar (Main_Menu);
  2184.   free (buf);
  2185. }
  2186. /* ---------------------------------------------------------------------- */
  2187. static void
  2188. init_module (void)
  2189. {
  2190.   char *s;
  2191.  
  2192.   s = malloc(25);
  2193.   s = "Modules listing:";
  2194.   module_pane_text = realloc (module_pane_text,
  2195.               (++module_text_count) * sizeof (char *));
  2196.   module_pane_text[module_text_count - 1] = strdup (s);
  2197.   free(s);
  2198.   s = get_module(module_text_count - 1);
  2199.   while (!undefined_symbol)
  2200.   {
  2201.     module_pane_text = realloc (module_pane_text,
  2202.               (++module_text_count) * sizeof (char *));
  2203.     module_pane_text[module_text_count - 1] = strdup (s);
  2204.     free(s);
  2205.     s = get_module(module_text_count - 1);
  2206.   }
  2207.   undefined_symbol = 0;
  2208. }
  2209. /* ---------------------------------------------------------------------- */
  2210. static void
  2211. put_help_line(const char *str)
  2212. {
  2213.   help_pane_text = realloc (help_pane_text,
  2214.                (++help_text_count) * sizeof (char *));
  2215.   help_pane_text[help_text_count - 1] = strdup (str);
  2216.  
  2217. }
  2218. /* ---------------------------------------------------------------------- */
  2219. static void
  2220. init_help (void)
  2221. { put_help_line("----------------------------------------------------------");
  2222.   put_help_line("GLOBAL KEY BINDINGS:");
  2223.   put_help_line(" ");
  2224.   put_help_line(" C-x C-c     Quit debugger.  You will be prompted first.");
  2225.   put_help_line(" C-x C-v     Save or load debugger context.");
  2226.   put_help_line(" C-r         Run program.");
  2227.   put_help_line(" C-h         Make Help pane active.");
  2228.   put_help_line(" BS          Make Help pane active.");
  2229.   put_help_line(" C-x C-w     Write active pane contents to a file.  Only");
  2230.   put_help_line("             the visible portion of the pane is saved.");
  2231.   put_help_line(" C-x C-f     Display contents of log file.");
  2232.   put_help_line(" C-x m       Toggle between color/monochrome mode.");
  2233.   put_help_line(" C-x C-e     Evaluate an expression and display result");
  2234.   put_help_line("             in the minibuffer.");
  2235.   put_help_line(" C-z         Show program output.  Press any key to return");
  2236.   put_help_line("             to the debugger.");
  2237.   put_help_line(" C-l         Redraw the screen.");
  2238.   put_help_line(" ESC C-p <c> Goto pane whose name begins with <c>.");
  2239.   put_help_line(" C-x C-o     Toggle between insert/overstrike mode.");
  2240.   put_help_line(" ");
  2241.   put_help_line("----------------------------------------------------------");
  2242.   put_help_line("MAIN MENU:");
  2243.   put_help_line(" ");
  2244.   put_help_line(" ESC ESC     Quit main menu, go to previously active pane.");
  2245.   put_help_line(" C-g         Quit main menu, go to previously active pane.");
  2246.   put_help_line(" f           Select File pulldown.");
  2247.   put_help_line(" p           Select Pane pulldown.");
  2248.   put_help_line(" l           Select Local pulldown.");
  2249.   put_help_line(" m           Select Miscellaneous pulldown.");
  2250.   put_help_line(" h           Select Help pulldown.");
  2251.   put_help_line(" CR          Select pulldown of highlighted choice.");
  2252.   put_help_line(" DN          Select pulldown of highlighted choice.");
  2253.   put_help_line(" C-n         Select pulldown of highlighted choice.");
  2254.   put_help_line(" C-f         Highlight next choice on main menu.");
  2255.   put_help_line(" TAB         Highlight next choice on main menu.");
  2256.   put_help_line(" RT          Highlight next choice on main menu.");
  2257.   put_help_line(" C-b         Highlight previous choice on main menu.");
  2258.   put_help_line(" S-TAB       Highlight previous choice on main menu.");
  2259.   put_help_line(" LT          Highlight previous choice on main menu.");
  2260.   put_help_line(" ");
  2261.   put_help_line("----------------------------------------------------------");
  2262.   put_help_line("PULLDOWNS:");
  2263.   put_help_line(" ");
  2264.   put_help_line(" ESC ESC     Go to main menu.");
  2265.   put_help_line(" CR          Select currently highlighted pulldown item.");
  2266.   put_help_line(" C-n         Highlight next pulldown item.");
  2267.   put_help_line(" DN          Highlight next pulldown item.");
  2268.   put_help_line(" C-p         Highlight previous pulldown item.");
  2269.   put_help_line(" UP          Highlight previous pulldown item.");
  2270.   put_help_line(" C-f         Show pulldown of next main menu choice.");
  2271.   put_help_line(" RT          Show pulldown of next main menu choice.");
  2272.   put_help_line(" TAB         Show pulldown of next main menu choice.");
  2273.   put_help_line(" C-b         Show pulldown of previous main menu choice.");
  2274.   put_help_line(" LT          Show pulldown of previous main menu choice.");
  2275.   put_help_line(" S-TAB       Show pulldown of previous main menu choice.");
  2276.   put_help_line(" ");
  2277.   put_help_line("----------------------------------------------------------");
  2278.   put_help_line("PANES:");
  2279.   put_help_line(" ");
  2280.   put_help_line(" ESC ESC     Go to main menu.");
  2281.   put_help_line(" C-x o       Go forward one pane.");
  2282.   put_help_line(" TAB         Go forward one pane.");
  2283.   put_help_line(" S-TAB       Go backward one pane.");
  2284.   put_help_line(" C-x C-x     Go to previous pane (and again to return).");
  2285.   put_help_line(" C-x ^       Make current pane taller by one line.");
  2286.   put_help_line(" C-x }       Make current pane wider by one line.");
  2287.   put_help_line(" C-x >       Scroll text right (show more of the left).");
  2288.   put_help_line(" C-x <       Scroll text left (show more of the right).");
  2289.   put_help_line(" C-f         Move forward one line/byte/halfword/fullword.");
  2290.   put_help_line(" RT          Move forward one line/byte/halfword/fullword.");
  2291.   put_help_line(" C-b         Move backward one line/byte/halfword/fullword.");
  2292.   put_help_line(" LT          Move backward one line/byte/halfword/fullword.");
  2293.   put_help_line(" C-n         Move forward one line.");
  2294.   put_help_line(" DN          Move forward one line.");
  2295.   put_help_line(" C-p         Move backward one line.");
  2296.   put_help_line(" UP          Move backward one line.");
  2297.   put_help_line(" C-v         Move forward one page.");
  2298.   put_help_line(" PGDN        Move forward one page.");
  2299.   put_help_line(" M-v         Move backward one page.");
  2300.   put_help_line(" PGUP        Move backward one page.");
  2301.   put_help_line(" M-<         Move to beginning of pane.");
  2302.   put_help_line(" HOME        Move to beginning of pane.");
  2303.   put_help_line(" M->         Move to end of pane.");
  2304.   put_help_line(" END         Move to end of pane.");
  2305.   put_help_line(" ");
  2306.   put_help_line("----------------------------------------------------------");
  2307.   put_help_line("DIALOG BOXES:");
  2308.   put_help_line(" ");
  2309.   put_help_line(" ESC ESC     Quit dialog box and discard any changes.");
  2310.   put_help_line(" C-g         Quit dialog box and discard any changes.");
  2311.   put_help_line(" TAB         Move to next field, if applicable.");
  2312.   put_help_line(" C-n         Move to next field, if applicable.");
  2313.   put_help_line(" DN          Move to next field, if applicable.");
  2314.   put_help_line(" S-TAB       Move to previous field, if applicable.");
  2315.   put_help_line(" C-p         Move to previous field, if applicable.");
  2316.   put_help_line(" UP          Move to previous field, if applicable.");
  2317.   put_help_line(" CR          Select highlighted item, if applicable.");
  2318.   put_help_line(" C-f         Move forward one character, if applicable.");
  2319.   put_help_line(" RT          Move forward one character, if applicable.");
  2320.   put_help_line(" C-b         Move backward one character, if applicable.");
  2321.   put_help_line(" LT          Move backward one character, if applicable.");
  2322.   put_help_line(" DEL         Delete character left of cursor.");
  2323.   put_help_line(" C-d         Delete character under cursor.");
  2324.   put_help_line(" CR          Accept input and");
  2325.   put_help_line("               - go to next field (if not on a button), or");
  2326.   put_help_line("               - take action specified by button.");
  2327.   put_help_line(" ");
  2328.   put_help_line("----------------------------------------------------------");
  2329.   put_help_line("MINBUFFER:");
  2330.   put_help_line(" ");
  2331.   put_help_line(" ESC ESC     Quit minibuffer and discard any changes.");
  2332.   put_help_line(" C-g         Quit minibuffer and discard any changes.");
  2333.   put_help_line(" C-f         Move forward one character, if applicable.");
  2334.   put_help_line(" RT          Move forward one character, if applicable.");
  2335.   put_help_line(" C-b         Move backward one character, if applicable.");
  2336.   put_help_line(" LT          Move backward one character, if applicable.");
  2337.   put_help_line(" DEL         Delete character left of cursor.");
  2338.   put_help_line(" C-d         Delete character under cursor.");
  2339.   put_help_line(" CR          Accept input.");
  2340.   put_help_line(" ");
  2341.   put_help_line("==========================================================");
  2342.   put_help_line(" PANE-SPECIFIC HELP");
  2343.   put_help_line("==========================================================");
  2344.   put_help_line("----------------------------------------------------------");
  2345.   put_help_line("HELP PANE:");
  2346.   put_help_line(" ");
  2347.   put_help_line(" CR          Make code pane active.");
  2348.   put_help_line(" C-g         Make code pane active.");
  2349.   put_help_line(" ");
  2350.   put_help_line("----------------------------------------------------------");
  2351.   put_help_line("CODE PANE:");
  2352.   put_help_line(" ");
  2353.   put_help_line(" s           Single step, stepping over function calls.");
  2354.   put_help_line(" S           Single step, stepping into function calls.");
  2355.   put_help_line(" C-c a       Animate - run program by single stepping at");
  2356.   put_help_line("             a user-specified speed.");
  2357.   put_help_line(" b           Toggle breakpoint on/off at current location.");
  2358.   put_help_line(" e           Edit breakpoint via dialog box.");
  2359.   put_help_line("             Breakpoint particulars are:");
  2360.   put_help_line("               Address   - breakpoint location.");
  2361.   put_help_line("               Type      - 0 == Code breakpoint.");
  2362.   put_help_line("                           1 == Data write breakpoint.");
  2363.   put_help_line("                           2 == Data read breakpoint.");
  2364.   put_help_line("               Class     - 0 == Always enabled.");
  2365.   put_help_line("                           1 == Breakpoint enabled only after");
  2366.   put_help_line("                                being reached <count> times.");
  2367.   put_help_line("                           2 == Breakpoint enabled only after");
  2368.   put_help_line("                                <condition> is true (nonzero).");
  2369.   put_help_line("               Count     - Number of hits before a class 1");
  2370.   put_help_line("                           breakpoint activates.");
  2371.   put_help_line("               Condition - Condition to be met before a");
  2372.   put_help_line("                           class 2 breakpoint activates.");
  2373.   put_help_line("                           The condition can be almost any");
  2374.   put_help_line("                           C expression.  For more info on");
  2375.   put_help_line("                           allowable expressions, see the");
  2376.   put_help_line("                           manual section on expressions.");
  2377.   put_help_line("                           Two examples are:");
  2378.   put_help_line(" _Odd_num >> 3 == 1 && (_Even_num >> _Shift_val || _Test)");
  2379.   put_help_line(" (([%esi + %eax * 4] & 0x5fff) >> 12) & 0x0f == 4");
  2380.   put_help_line("               Size      - The Size parameter allows you");
  2381.   put_help_line("                           to specify the maximum size to");
  2382.   put_help_line("                           be used during evaluation of");
  2383.   put_help_line("                           expressions.");
  2384.   put_help_line(" C-c t       Trace to current address.  Same as toggling");
  2385.   put_help_line("             breakpoint, then running program.");
  2386.   put_help_line(" <n> CR      Disassemble and display memory at specified");
  2387.   put_help_line("             decimal address.");
  2388.   put_help_line(" <x> CR      Disassemble and display memory at specified");
  2389.   put_help_line("             hexadecimal address.");
  2390.   put_help_line(" _<sym> CR   Disassemble and display memory at address");
  2391.   put_help_line("             specified by symbol <sym>.");
  2392.   put_help_line(" %<sym> CR   Disassemble and display memory at address");
  2393.   put_help_line("             specified by value in register denoted by");
  2394.   put_help_line("             symbol <sym>.");
  2395.   put_help_line(" <exp> CR    Disassemble and display memory at address");
  2396.   put_help_line("             specified by value of expression <exp>.");
  2397.   put_help_line(" i           Disassemble and display memory at address");
  2398.   put_help_line("             specified by EIP (current run location).");
  2399.   put_help_line(" C-c i       Set EIP to address of currently highlighted");
  2400.   put_help_line("             instruction.");
  2401.   put_help_line(" p           Modify performance analyzer settings.");
  2402.   put_help_line(" C-c p       Start performance analyzer and run program");
  2403.   put_help_line("             (if performance analyzer timer has been set).");
  2404.   put_help_line(" M-b         Move pane's origin left by one byte.");
  2405.   put_help_line(" M-f         Move pane's origin right by one byte.");
  2406.   put_help_line(" C-x / <c>   Save highlighted location in debugger code");
  2407.   put_help_line("             pane register <c>.");
  2408.   put_help_line(" C-x j <c>   Disassemble and display memory at location");
  2409.   put_help_line("             saved in debugger code pane register <c>.");
  2410.   put_help_line(" ");
  2411.   put_help_line("----------------------------------------------------------");
  2412.   put_help_line("DATA PANE:");
  2413.   put_help_line(" ");
  2414.   put_help_line(" w           Toggle data write breakpoint on/off.");
  2415.   put_help_line(" r           Toggle data read/write breakpoint on/off.");
  2416.   put_help_line(" e           Edit data read or read/write breakpoint.");
  2417.   put_help_line("             Breakpoint particulars are:");
  2418.   put_help_line("               Address   - breakpoint location.");
  2419.   put_help_line("               Type      - 0 == Code breakpoint.");
  2420.   put_help_line("                           1 == Data write breakpoint.");
  2421.   put_help_line("                           2 == Data read breakpoint.");
  2422.   put_help_line("               Class     - 0 == Always enabled.");
  2423.   put_help_line("                           1 == Breakpoint enabled only after");
  2424.   put_help_line("                                being reached <count> times.");
  2425.   put_help_line("                           2 == Breakpoint enabled only after");
  2426.   put_help_line("                                <condition> is true (nonzero).");
  2427.   put_help_line("               Count     - Number of hits before a class 1");
  2428.   put_help_line("                           breakpoint activates.");
  2429.   put_help_line("               Condition - Condition to be met before a");
  2430.   put_help_line("                           class 2 breakpoint activates.");
  2431.   put_help_line("                           The condition can be almost any");
  2432.   put_help_line("                           C expression.  For more info on");
  2433.   put_help_line("                           allowable expressions, see the");
  2434.   put_help_line("                           manual section on expressions.");
  2435.   put_help_line("                           Two examples are:");
  2436.   put_help_line(" _Odd_num >> 3 == 1 && (_Even_num >> _Shift_val || _Test)");
  2437.   put_help_line(" (([%esi + %eax * 4] & 0x5fff) >> 12) & 0x0f == 4");
  2438.   put_help_line("               Size      - The Size parameter allows you");
  2439.   put_help_line("                           to specify the maximum size to");
  2440.   put_help_line("                           be used during evaluation of");
  2441.   put_help_line("                           expressions.");
  2442.   put_help_line(" b           Display data in byte format.");
  2443.   put_help_line(" h           Display data in halfword (two byte) format.");
  2444.   put_help_line(" f           Display data in fullword (four byte) format.");
  2445.   put_help_line(" <n> CR      Display memory at specified decimal address.");
  2446.   put_help_line(" <x> CR      Display memory at specified hexadecimal");
  2447.   put_help_line("             address.");
  2448.   put_help_line(" _<sym> CR   Display memory at address specified by");
  2449.   put_help_line("             symbol <sym>.");
  2450.   put_help_line(" %<sym> CR   Display memory at address specified by value");
  2451.   put_help_line("             in register denoted by symbol <sym>.");
  2452.   put_help_line(" <exp> CR    Display memory at address specified by value");
  2453.   put_help_line("             of expression <exp>.");
  2454.   put_help_line(" i           Display memory at address specified by EIP");
  2455.   put_help_line("             (current run location).");
  2456.   put_help_line(" s           Display memory at address specified by ESP");
  2457.   put_help_line("             (current stack pointer).");
  2458.   put_help_line(" *           Dereference currently highlighted value.");
  2459.   put_help_line(" @           Retrace steps after a '*' command.  Up to");
  2460.   put_help_line("             five (5) steps back are allowed.");
  2461.   put_help_line(" n           Display data in customized format.");
  2462.   put_help_line(" p           Input/output from/to ports as follows:");
  2463.   put_help_line("               Size - 1 = byte, 2 = word, 3 = dword");
  2464.   put_help_line("                      b = byte, h = word, f = dword");
  2465.   put_help_line("               Port - port to access");
  2466.   put_help_line("               Data - data to write");
  2467.   put_help_line("               <In>  button - input from port");
  2468.   put_help_line("               <Out> button - output to port");
  2469.   put_help_line(" M-b         Move pane's origin left by one byte.");
  2470.   put_help_line(" M-f         Move pane's origin right by one byte.");
  2471.   put_help_line(" C-c m       Modify memory at cursor");
  2472.   put_help_line(" C-c u       Undo last memory modification.  No more than");
  2473.   put_help_line("             five (5) modifications can be undone.");
  2474.   put_help_line(" C-c s       Search memory.");
  2475.   put_help_line(" C-x / <c>   Save highlighted location in debugger data");
  2476.   put_help_line("             pane register <c>.");
  2477.   put_help_line(" C-x j <c>   Display memory at location saved in");
  2478.   put_help_line("             debugger data pane register <c>.");
  2479.   put_help_line(" ");
  2480.   put_help_line("----------------------------------------------------------");
  2481.   put_help_line("REGISTERS PANE:");
  2482.   put_help_line(" ");
  2483.   put_help_line(" C-c m       Modify register at cursor.");
  2484.   put_help_line(" C-c u       Undo last register modification.  No more");
  2485.   put_help_line("             than five (5) modifications can be undone.");
  2486.   put_help_line(" ");
  2487.   put_help_line("----------------------------------------------------------");
  2488.   put_help_line("FLAGS PANE:");
  2489.   put_help_line(" ");
  2490.   put_help_line(" All commands accessed via local menu.");
  2491.   put_help_line(" ");
  2492.   put_help_line("----------------------------------------------------------");
  2493.   put_help_line("BREAKPOINT PANE:");
  2494.   put_help_line(" ");
  2495.   put_help_line(" CR          Goto location of currently highlighted");
  2496.   put_help_line("             breakpoint, in code or data pane, as");
  2497.   put_help_line("             appropriate.");
  2498.   put_help_line(" DEL         Delete currently highlighted breakpoint.");
  2499.   put_help_line(" C-d         Delete currently highlighted breakpoint.");
  2500.   put_help_line(" C-e         Edit currently highlighted breakpoint.");
  2501.   put_help_line(" C-k         Delete from currently highlighted breakpoint");
  2502.   put_help_line("             up to the last breakpoint.");
  2503.   put_help_line(" C-y         Restore from previous deletion.  No more");
  2504.   put_help_line("             than five (5) deletions can be undone.");
  2505.   put_help_line(" ");
  2506.   put_help_line("----------------------------------------------------------");
  2507.   put_help_line("WHEREIS PANE:");
  2508.   put_help_line(" ");
  2509.   put_help_line(" CR          Display data/code at address represented by");
  2510.   put_help_line("             currently highlighted symbol.");
  2511.   put_help_line(" _<sym> CR   Find <sym> in symbol table");
  2512.   put_help_line("             Permissible wildcards are:");
  2513.   put_help_line("               ? - Matches one character");
  2514.   put_help_line("               * - Matches any number of characters");
  2515.   put_help_line(" ");
  2516.   put_help_line("----------------------------------------------------------");
  2517.   put_help_line("MODULE PANE:");
  2518.   put_help_line(" ");
  2519.   put_help_line(" CR          Prompt for a line number, disassemble and");
  2520.   put_help_line("             display code at that location.");
  2521.   put_help_line(" ");
  2522.   put_help_line("----------------------------------------------------------");
  2523.   put_help_line("NPX PANE: ");
  2524.   put_help_line(" ");
  2525.   put_help_line(" C-c e       Empty register.");
  2526.   put_help_line(" C-c n       Negate register contents.");
  2527.   put_help_line(" C-c z       Zero register.");
  2528.   put_help_line(" C-c m       Modify register contents.");
  2529.   put_help_line(" C-c u       Undo last register modification.  No more");
  2530.   put_help_line("             than five (5) modifications can be undone.");
  2531.   put_help_line(" ");
  2532.   put_help_line("----------------------------------------------------------");
  2533.   put_help_line("PERFORMANCE ANALYZER DATA VIEWER:");
  2534.   put_help_line(" ");
  2535.   put_help_line(" C-x C-w     Log performance analyzer results to file.");
  2536.   put_help_line(" ");
  2537.   put_help_line("----------------------------------------------------------");
  2538.   put_help_line("STACK PANE:");
  2539.   put_help_line(" ");
  2540.   put_help_line(" CR          Select highlighted location and display");
  2541.   put_help_line("             in data pane.");
  2542.   put_help_line(" ");
  2543.   put_help_line("----------------------------------------------------------");
  2544.   put_help_line("INFO PANE:");
  2545.   put_help_line(" ");
  2546.   put_help_line(" No commands available.");
  2547.   put_help_line(" ");
  2548.   put_help_line("==========================================================");
  2549.   put_help_line(" SYNTAX AND VALUES");
  2550.   put_help_line("==========================================================");
  2551.   put_help_line("----------------------------------------------------------");
  2552.   put_help_line("C EXPRESSIONS ALLOWED:");
  2553.   put_help_line(" ");
  2554.   put_help_line("   Syntax:");
  2555.   put_help_line("     <expr>  = <l_exp> [<l_op> <l_exp> ...]");
  2556.   put_help_line("     <l_exp> = <a_exp> [<r_op> <a_exp> ...] | ");
  2557.   put_help_line("               (<l_exp>) | !<l_exp>");
  2558.   put_help_line("     <a_exp> = <a_exp>|<identifier> [<a_op> ");
  2559.   put_help_line("               <a_exp>|<identifier> ...] | (<a_exp>)");
  2560.   put_help_line("     <identifier> = <identifier> | <[<a_exp>]><size>");
  2561.   put_help_line("   where");
  2562.   put_help_line("     <l_exp>      is a logical expression.");
  2563.   put_help_line("     <l_op>       is one of: && ||");
  2564.   put_help_line("     <a_exp>      is an arithmetic expression");
  2565.   put_help_line("     <r_op>       is one of: < <= == != >= >");
  2566.   put_help_line("     <a_op>       is one of: + - * / >> << & | ! ~");
  2567.   put_help_line("     <identifier> is an identifiler (a symbol, register) ");
  2568.   put_help_line("                  a number, or a memory reference.");
  2569.   put_help_line(" ");
  2570.   put_help_line("     * <identifier> can be a global variable name,");
  2571.   put_help_line("       symbolic constant, constant value, register name,");
  2572.   put_help_line("       or memory reference (i.e. an expression which");
  2573.   put_help_line("       evaluates to a memory location).");
  2574.   put_help_line("     * All register names must begin with a '%' (percent) ");
  2575.   put_help_line("       character. ");
  2576.   put_help_line("     * All memory references have the structure: ");
  2577.   put_help_line("         [<address expression>]size ");
  2578.   put_help_line("       where size can be b, h, f, or nothing.");
  2579.   put_help_line("       b: 1 byte. h: 2 bytes. f: 4 bytes. Any other");
  2580.   put_help_line("       character immediately following the right square ");
  2581.   put_help_line("       bracket (]) and is not one of the above characters");
  2582.   put_help_line("       will be interpreted as part of the expression.");
  2583.   put_help_line("       By default (if neither b, h, or f follows the");
  2584.   put_help_line("       right square bracket,) the reference will read");
  2585.   put_help_line("       4 bytes from memory.");
  2586.   put_help_line("     * When constructing expressions, be aware that");
  2587.   put_help_line("       the modulo (%) operator is not allowed, since");
  2588.   put_help_line("       it conficts with the register naming scheme.");
  2589.   put_help_line("       To perform a modulo, use divide (/) and");
  2590.   put_help_line("       subtract (-): (a % b) == (a - a / b)");
  2591.   put_help_line("     * When constructing expressions, be wary");
  2592.   put_help_line("       of possible overflow (the debugger uses");
  2593.   put_help_line("       32 bit arithmetic to evaluate expressions).");
  2594.   put_help_line(" ");
  2595.   put_help_line("   Examples of valid expressions: ");
  2596.   put_help_line(" ");
  2597.   put_help_line("     _Odd_num >> 3 == 1 && (_Even_num >> _Shift_val || _Test)");
  2598.   put_help_line("     (([%esi + %eax * 4] & 0x5fff) >> 12) & 0x0f == 4  ");
  2599.   put_help_line(" ");
  2600.   put_help_line("----------------------------------------------------------");
  2601.   put_help_line("REMOTE DEBUGGING DEVICES");
  2602.   put_help_line(" ");
  2603.   put_help_line("    con       : console. ");
  2604.   put_help_line("    com_one   : COM1. ");
  2605.   put_help_line("    com_two   : COM2. ");
  2606.   put_help_line("    com_three : COM3. ");
  2607.   put_help_line("    com_four  : COM4. ");
  2608.   put_help_line(" ");
  2609.   put_help_line("==========================================================");
  2610. }
  2611. /* ---------------------------------------------------------------------- */
  2612. static void
  2613. initialize (void)
  2614. { int i;
  2615.  
  2616.   using_com_port_num = remote;
  2617.   init_io (using_com_port_num);
  2618.   if (_go32_info_block.run_mode != _GO32_RUN_MODE_DPMI)
  2619.     test_npx ();
  2620.  
  2621.   debug_screen_p = 0;
  2622.   toplines = (rows / 2) + 4;
  2623.   bottomlines = rows - 4 - toplines;
  2624.   main_x1 = cols - 18;
  2625.   main_x2 = cols - 5;
  2626.   main_x3 = 46;                  
  2627.  
  2628.   code_pane_pos = malloc ((rows + 2) * sizeof (word32));
  2629.   stack_dump_pos = malloc ((rows + 2) * sizeof (word32));
  2630.  
  2631.   debug_screen_save = get_screen ();
  2632.   debug_screen_save[1] = debug_screen_save[2] = 0;  /* Patch cursor pos.  */
  2633.  
  2634.   pane = 10;
  2635.   pane_pos = 0;
  2636.   for (i = 0; i < PANECOUNT; i++) pane_positions[i] = 0;
  2637.   data_dump_origin = areas[A_data].first_addr;
  2638.   data_dump_size = 1;
  2639.   code_dump_origin = a_tss.tss_eip;
  2640.   stack_dump_origin = 0;
  2641.   breakpoint_origin = 0;
  2642.   breakpoint_count = 0;
  2643.   breakpoint_table = malloc (breakpoint_count * sizeof (BP_ENTRY));
  2644.   whereis_origin = 0;
  2645.   whereis_sym_count = 0;
  2646.   whereis_pane_sym = malloc (whereis_sym_count * sizeof (char *));
  2647.   module_origin = 0;
  2648.   module_text_count = 0;
  2649.   module_pane_text = malloc (module_text_count * sizeof (char *));
  2650.   init_module ();
  2651.   help_origin = 0;
  2652.   help_text_count = 0;
  2653.   help_pane_text = malloc (help_text_count * sizeof (char *));
  2654.   init_help();
  2655.   flag_pane_origin = 0;
  2656.   reg_pane_origin = 0;
  2657.   help_pane_active = 1;
  2658.   npx_pane_active = stack_pane_active = info_pane_active
  2659.     = whereis_pane_active = module_pane_active
  2660.     = code_pane_active = 0;
  2661.   sprintf (active_pane_name, "Help Pane");
  2662.   
  2663.   init_eval_data (0, 0); /* Force to calculate addresses */
  2664.   init_undo (&data_undo, free_do_nothing);
  2665.   init_undo (®ister_undo, free_do_nothing);
  2666.   init_undo (&npx_undo, free_npx);
  2667.   init_undo (&breakpoint_undo, free_breakpoint);                          
  2668.  
  2669.   redraw (1);
  2670.   message (CL_Info, "Ladybug version %d.%02d", MAJOR_VER, MINOR_VER);
  2671. }
  2672. /* ---------------------------------------------------------------------- */
  2673. static void
  2674. view_eval_data (void)
  2675. {
  2676.   EVAL_SEG_INFO swap_data;
  2677.   EVAL_DATA_TABLE temp_data;
  2678.   int i, j, percent_bar;
  2679.   long percent;
  2680.   int32 delta;
  2681.   word32 total_hits = 0, in_hits = 0, out_hits;
  2682.   char *save, *name = alloca (256), *name2 = alloca (256), *p;
  2683.  
  2684.   if (total_hits_count == 0)
  2685.   { message (CL_Error,
  2686.              "Nothing has been recorded, cannot calculate percentage");
  2687.     return;
  2688.   }
  2689.  
  2690.   for (i = 0; i < EVAL_SEGMENTS; i++)
  2691.   { temp_data[i].start_addr = evaluation_data[i].start_addr;
  2692.     temp_data[i].stop_addr  = evaluation_data[i].stop_addr;
  2693.     temp_data[i].hits_count = evaluation_data[i].hits_count;
  2694.     total_hits += temp_data[i].hits_count;
  2695.   }
  2696.  
  2697.   for (i = 0; i < EVAL_SEGMENTS - 1; i++)
  2698.     for (j = i + 1; j < EVAL_SEGMENTS; j++)
  2699.       if (temp_data[i].hits_count < temp_data[j].hits_count)
  2700.       {    swap_data.start_addr = temp_data[i].start_addr;
  2701.         swap_data.stop_addr  = temp_data[i].stop_addr;
  2702.         swap_data.hits_count = temp_data[i].hits_count;
  2703.  
  2704.         temp_data[i].start_addr = temp_data[j].start_addr;
  2705.         temp_data[i].stop_addr  = temp_data[j].stop_addr;
  2706.         temp_data[i].hits_count = temp_data[j].hits_count;
  2707.  
  2708.         temp_data[j].start_addr = swap_data.start_addr;
  2709.         temp_data[j].stop_addr  = swap_data.stop_addr;
  2710.         temp_data[j].hits_count = swap_data.hits_count;
  2711.       }
  2712.   j = (rows / 2) - 4;
  2713.   save = debug_screen_save;
  2714.   debug_screen_save = get_screen ();
  2715.   screen_attr = screen_attr_normal;
  2716.   clear_screen ();
  2717.   screen_attr = screen_attr_ffocus;
  2718.   double_frame (0, 0, cols - 1, rows - 1, "Performance Analyzer's Result");
  2719.   screen_attr = screen_attr_normal;
  2720.  
  2721.   sprintf (name, "Most called segments (from %08lx to %08lx)",
  2722.            evaluation_data[0].start_addr, 
  2723.            evaluation_data[EVAL_SEGMENTS - 1].stop_addr);
  2724.   putl (cols / 2 - 24, 1, 50, name);
  2725.   for (i = 0; i < j; i++)
  2726.     in_hits += temp_data[i].hits_count;
  2727.  
  2728.   if (in_hits == 0)
  2729.     putl (2, 3, cols-5, "Nothing is recorded inside the given addresses.");
  2730.   else
  2731.   { for (i = 0; i < j; i++)
  2732.     {                                                                           
  2733.       percent = (long)temp_data[i].hits_count;
  2734.       percent *= 100;
  2735.  
  2736.       p = syms_val2name (temp_data[i].start_addr, &delta);
  2737.       if (p[0] != '0')
  2738.         if (delta)
  2739.           sprintf (name, "(%s+%#lx)", p, delta);
  2740.         else
  2741.           sprintf (name, "(%s)",p);
  2742.       else
  2743.         sprintf(name, "(No Symbols");
  2744.       p = syms_val2name (temp_data[i].stop_addr, &delta);
  2745.       if (p[0] != '0')
  2746.         if (delta)
  2747.           sprintf (name2, "(%s+%#lx)", p, delta);
  2748.         else
  2749.           sprintf (name2, "(%s)", p);
  2750.       else
  2751.         sprintf(name2, "No Symbols)");
  2752.  
  2753.       sprintf (read_buffer, "%02ld.%-1ld%% %08lx-%08lx %s-%s",
  2754.                percent / total_hits, ((percent % total_hits) * 10) / total_hits,
  2755.                temp_data[i].start_addr, temp_data[i].stop_addr,
  2756.                name, name2);
  2757.       percent /= 100;
  2758.       percent_bar = percent * (cols - 5) / total_hits;
  2759.  
  2760.       putl (2, i * 2 + 3, cols - 4, read_buffer);
  2761.       draw (2, i * 2 + 4, '-', 1, percent_bar);
  2762.     }
  2763.  
  2764.     out_hits = total_hits - in_hits;
  2765.     percent = out_hits * 100;
  2766.  
  2767.     sprintf (name, "%02ld.%-1ld%% : Other segments (%% of total in-range hits)", 
  2768.              percent / total_hits, ((percent % total_hits) * 10) / total_hits);
  2769.     putl (2, i * 2 + 3, cols - 4, name);           
  2770.     percent /= 100;
  2771.     percent_bar = percent * (cols - 5) / in_hits;
  2772.     draw (2, i * 2 + 4, '-', 1, percent_bar);
  2773.     i++;
  2774.   }
  2775.   out_hits = total_hits_count - total_hits;
  2776.   percent = out_hits * 100;
  2777.  
  2778.   sprintf (name, "%02ld.%-1ld%% : Outside of defined range (over total of %010ld)",
  2779.            percent / total_hits_count, 
  2780.            ((percent % total_hits_count) * 10) / total_hits_count, 
  2781.            total_hits_count);
  2782.   putl (2, i * 2 + 3, cols - 4, name);               
  2783.   percent /= 100;
  2784.   percent_bar = percent * (cols - 5) / total_hits_count;
  2785.   draw (2, i * 2 + 4, '-', 1, percent_bar);
  2786.  
  2787.   put_screen (debug_screen_save);
  2788.   do
  2789.   { i = getykey ();
  2790.     if (i == K_Control_X)
  2791.     { i = getykey ();
  2792.       if (i == K_Control_W)
  2793.       { write_log (1, 1, cols - 1, rows - 1);
  2794.         i = 0;
  2795.       }
  2796.     }
  2797.   } while (i == 0);
  2798.   free (debug_screen_save);
  2799.   debug_screen_save = save;
  2800.   put_screen (debug_screen_save);
  2801. }
  2802. /* ---------------------------------------------------------------------- */
  2803. static void
  2804. init_time (char *output, char *input, word32 addr)
  2805. { sprintf (output, "%s", *(int *)addr ? "On " : "Off");
  2806. }
  2807. /* ---------------------------------------------------------------------- */
  2808. static int
  2809. edtime (char *text, word32 addr, int x, int y, int len, int *key)
  2810. { if (*key == K_Return)                       /* Only enter toggles timer */
  2811.   { if (*(int *)addr)
  2812.       reset_timer ();
  2813.     else
  2814.       set_timer ();
  2815.   }
  2816.   *key = 0;
  2817.   return 1;
  2818. }          
  2819. /* ---------------------------------------------------------------------- */
  2820. static int
  2821. action_init (DIALOG_ITEM dialog_data[])
  2822. { word32 start_addr = 0, stop_addr = 0;
  2823.   int ok;
  2824.  
  2825.   if (!my_read_string ("Enter start address: "))
  2826.     start_addr = parse_expression(4, read_buffer, &ok); 
  2827.   if (ok != ParseError_ok)
  2828.   { message (CL_Error, "Bad address: %s", read_buffer);
  2829.     return (0);
  2830.   }
  2831.   if (!my_read_string ("Enter stop address: "))
  2832.     stop_addr = parse_expression(4, read_buffer, &ok);
  2833.   if (ok != ParseError_ok)
  2834.   { message (CL_Error, "Bad address: %s", read_buffer);
  2835.     return (0);
  2836.   }
  2837.   init_eval_data (start_addr, stop_addr);
  2838.   return (1);
  2839. }
  2840. /* ---------------------------------------------------------------------- */
  2841. static int
  2842. action_view (DIALOG_ITEM dialog_data[])
  2843. { view_eval_data ();
  2844.   return (1);
  2845. }
  2846. /* ---------------------------------------------------------------------- */
  2847. static void
  2848. evaluation_dialogue (void)
  2849. { int ret = 0;
  2850.   static DIALOG_ITEM dialog_data[] = {
  2851.     {"Timer    :", 0 , 03, 1, format_asis, eval_asis, init_time, edtime},
  2852.     {"Segments :", 0 , 05, 0, format_int , eval_word, init_int , editor},
  2853.     {0           , 0 , 0 , 0, 0          , 0        , 0        , 0     }
  2854.   };
  2855.   static BUTTON_ITEM button_data[] = {
  2856.     {" ReInit ", 1, action_init},
  2857.     {"  View  ", 1, action_view},
  2858.     {"  Done  ", 0, action_done},
  2859.     {0         , 0, 0          }
  2860.   };
  2861.   dialog_data[0].return_addr = (word32)&timer_is_set;
  2862.   dialog_data[1].return_addr = (word32)&total_segments;
  2863.   dialog ("P.A. Settings", dialog_data, button_data, &ret);
  2864. }
  2865. /* ---------------------------------------------------------------------- */
  2866. static MENU_ITEM Code_Local_Menu[] = {
  2867.        {"Current Highlighted Item               ", 1        , ""     , 0},
  2868.        {"Run                                ~^R~", ITEM_TYPE, "\022" , 0},
  2869.        {"Step into function                  ~S~", ITEM_TYPE, "S"    , 0},
  2870.        {"Step over function                  ~s~", ITEM_TYPE, "s"    , 0},
  2871.        {"Trace to current address         ~^C t~", ITEM_TYPE, "\3t"  , 0},
  2872.        {"Animate                          ~^C a~", ITEM_TYPE, "\3a"  , 0},
  2873.        {"Toggle breakpoint                   ~b~", ITEM_TYPE, "b"    , 0},
  2874.        {"Toggle/edit breakpoint              ~e~", ITEM_TYPE, "e"    , 0},
  2875.        {"Perfomance analyzer settings        ~p~", ITEM_TYPE, "p"    , 0},
  2876.        {"Start performance analyzer       ~^C p~", ITEM_TYPE, "\3p"  , 0},
  2877.        {"Display code at EIP                 ~i~", ITEM_TYPE, "i"    , 0},
  2878.        {"Set EIP to current address       ~^C i~", ITEM_TYPE, "\3i"  , 0},
  2879.        {"Move pane's origin left one byte  ~M b~", ITEM_TYPE, "\033b", 0},
  2880.        {"Move pane's origin right one byte ~M f~", ITEM_TYPE, "\033f", 0},
  2881.        {0                                        , 0        , ""     , 0}
  2882. };                                                     
  2883. /* ---------------------------------------------------------------------- */
  2884. static void
  2885. code_pane_command (int key)
  2886. { int b;
  2887.             
  2888.   if (key == 0)
  2889.   { pop_menu (Code_Local_Menu, "Code", 1, 3, &b);
  2890.     control_c = 0;
  2891.     control_x = 0;
  2892.     escaped   = 0;
  2893.     switch (b)
  2894.     { case 1:
  2895.         step (2);    /* Run is a global command... */
  2896.         break;
  2897.       case 2:  
  2898.         key = 'S';
  2899.         break;
  2900.       case 3:    
  2901.         key = 's';
  2902.         break;
  2903.       case 4:  
  2904.         control_c = 1;
  2905.         key = 't';
  2906.         break;                                         
  2907.       case 5:
  2908.         control_c = 1;
  2909.         key = 'a';
  2910.         break;
  2911.       case 6:
  2912.         key = 'b';
  2913.         break;
  2914.       case 7:
  2915.         key = 'e';
  2916.         break;
  2917.       case 8:
  2918.         key = 'p';
  2919.         break;
  2920.       case 9:    
  2921.         control_c = 1;
  2922.         key = 'p';
  2923.         break;
  2924.       case 10:
  2925.         key = 'i';
  2926.         break;
  2927.       case 11:   
  2928.         control_c = 1;
  2929.         key = 'i';
  2930.         break;
  2931.       case 12:
  2932.         escaped = 1;
  2933.         key = 'b';
  2934.         break;
  2935.       case 13:
  2936.         escaped = 1;
  2937.         key = 'f';
  2938.         break;
  2939.     }  
  2940.   }
  2941.   if (control_c)
  2942.   { switch (key)
  2943.     { case 'a':                            /* Animate               */
  2944.         if (using_com_port_num)
  2945.         { message (CL_Error, "Local mode only.");
  2946.           break;
  2947.         }
  2948.         if (!my_read_string("Time between step (tens of msecs): "))
  2949.         { unsigned long milisec;
  2950.           char *endp;
  2951.           int stopped = 0;
  2952.  
  2953.           milisec = strtoul(read_buffer, &endp, 10);
  2954.           if (milisec > 0)
  2955.             while (!stopped)
  2956.             { step(0);
  2957.              stopped = short_sleep(milisec);
  2958.             }
  2959.         }
  2960.         break;
  2961.       case 't':                            /* Trace                 */
  2962.         b = set_breakpoint (BP_Code, 0, code_pane_pos[pane_pos]);
  2963.         step (2);
  2964.         reset_breakpoint (b);
  2965.         break;
  2966.       case 'i':                            /* Set EIP to current    */
  2967.         a_tss.tss_eip = code_pane_pos[pane_pos];
  2968.         break;
  2969.       case 'p':                            /* Start perfom. analyzer*/
  2970.         if (timer_is_set)
  2971.         { start_evaluate ();
  2972.           step (2);
  2973.           stop_evaluate ();
  2974.           reset_timer ();
  2975.         } else
  2976.           message (CL_Error, "Timer has not been set -- Action aborted.");
  2977.         break;
  2978.     }
  2979.   }
  2980.   if (control_x)
  2981.   { switch (key)
  2982.     { case '/':                            /* Save to register      */
  2983.         key = my_get_char ("Save address to which register (0..A..z)? ");
  2984.         if (key >= '0' && key <= 'z')
  2985.            registers[key - '0'] = code_pane_pos[pane_pos];
  2986.         break;
  2987.       case 'j':                            /* Load from register    */
  2988.       case 'J':       
  2989.         key = my_get_char ("Load address from which register (0..A..z)? ");
  2990.         if (key >= '0' && key <= 'z')
  2991.           if (registers[key - '0'])
  2992.             code_pane_goto (registers[key - '0']);
  2993.         break;
  2994.     }                                                           
  2995.   }
  2996.   if (escaped)
  2997.   { switch (key)
  2998.     { case 'b':                            /* Move origin left      */
  2999.       case 'B':       
  3000.         code_dump_origin--;
  3001.         break;
  3002.       case 'f':                            /* Move origin right     */
  3003.       case 'F':       
  3004.         code_dump_origin++;
  3005.         break;
  3006.       case 'v':                            /* PageUp                */
  3007.       case 'V':       
  3008.         escaped = 0;
  3009.         key = K_PageUp;
  3010.         break;
  3011.     }                                                           
  3012.   }
  3013.   if (!(control_c || control_x || escaped))
  3014.   { switch (key)
  3015.     { case K_Up:
  3016.       case K_EUp:
  3017.       case K_Control_B:
  3018.       case K_Control_P:
  3019.         if (pane_pos > 0)
  3020.           pane_pos--;
  3021.         else
  3022.           code_pane_goto (code_skip (code_dump_origin, -1));
  3023.         break;
  3024.       case K_Down:
  3025.       case K_EDown:    
  3026.       case K_Control_F:
  3027.       case K_Control_N:
  3028.         if (pane_pos < toplines - 2)
  3029.           pane_pos++;
  3030.         else
  3031.           code_dump_origin =
  3032.              code_pane_pos[0] == code_pane_pos[1]
  3033.              ? code_pane_pos[2] : code_pane_pos[1];
  3034.         break;
  3035.       case K_PageUp:
  3036.       case K_EPageUp:  
  3037.         code_dump_origin = code_skip (code_dump_origin, 2 - toplines);
  3038.         break;
  3039.       case K_PageDown:
  3040.       case K_EPageDown:
  3041.       case K_Control_V:
  3042.         code_dump_origin = code_dump_last + 1;
  3043.         break;
  3044.       case 'b':
  3045.       case 'B':
  3046.         b = get_breakpoint (BP_Code, -1, code_pane_pos[pane_pos]);
  3047.         if (b != -1)
  3048.           reset_breakpoint (b);
  3049.         else
  3050.           b = set_breakpoint (BP_Code, 4, code_pane_pos[pane_pos]);
  3051.         break;
  3052.       case 'e':
  3053.       case 'E':
  3054.         b = get_breakpoint (BP_Code, -1, code_pane_pos[pane_pos]);
  3055.         if (b == -1)
  3056.         { b = set_breakpoint (BP_Code, 4, code_pane_pos[pane_pos]);
  3057.           if (edit_breakpoint(b))
  3058.             reset_breakpoint (b);
  3059.         } else
  3060.           edit_breakpoint (b);
  3061.         break;
  3062.       case 'i':
  3063.       case 'I':
  3064.         code_pane_goto (a_tss.tss_eip);
  3065.         break;
  3066.       case 'p':
  3067.       case 'P':
  3068.         evaluation_dialogue ();
  3069.         break;
  3070.       case 's':
  3071.         step (1);
  3072.         break;
  3073.       case 'S':
  3074.         step (0);
  3075.         break;
  3076.       default:
  3077.         if ((key == '_') || (key == '%') ||
  3078.             (key == '(') || (key >= '0' && key <= '9'))
  3079.         { int res, ok;
  3080.           char s[2], *p;
  3081.     
  3082.           s[0] = key; s[1] = '\0';
  3083.           if (last_addr[0])
  3084.             ok = !read_string (last_addr);
  3085.           else
  3086.             ok = !read_string (key == '=' ? "" : s);
  3087.           strcpy (last_addr, read_buffer);
  3088.           p = read_buffer;
  3089.           while (*p != 0 && *p == ' ')
  3090.             p++;
  3091.           if (*p)
  3092.           { if (ok)
  3093.             { res = parse_expression (4, read_buffer, &ok);
  3094.               if (ok == ParseError_ok) 
  3095.               { message (CL_Info, "Found address %s.", read_buffer);
  3096.                 code_pane_goto (res);
  3097.                 last_addr[0] = 0;
  3098.               }
  3099.               else
  3100.                 message (CL_Error, "Bad address: %s", read_buffer);
  3101.             }
  3102.           }
  3103.         }
  3104.         break;
  3105.     }
  3106.   }
  3107.   redraw (0);
  3108. }
  3109. /* ---------------------------------------------------------------------- */
  3110. static MENU_ITEM Register_Local_Menu[] = {
  3111.        {"Current Highlighted Item      ", 1        , ""   , 0},
  3112.        {"Modify current register ~^C m~", ITEM_TYPE, "\3m", 0},
  3113.        {"Undo last modification  ~^C u~", ITEM_TYPE, "\3u", 0},
  3114.        {0                               , 0        , ""   , 0}
  3115. };                                                     
  3116. /* ---------------------------------------------------------------------- */
  3117. static void
  3118. register_pane_command (int key)
  3119. { int curr = pane_pos + reg_pane_origin;
  3120.   int b;
  3121.  
  3122.   if (key == 0)
  3123.   { pop_menu (Register_Local_Menu, "Registers", cols - 33, 3, &b);
  3124.     switch (b)
  3125.     { case 1: 
  3126.         control_c = 1;
  3127.         key = 'm';
  3128.         break;
  3129.       case 2:
  3130.         control_c = 1;
  3131.         key = 'u';
  3132.         break;
  3133.     }
  3134.   }               
  3135.   if (control_c)
  3136.   { switch (key)
  3137.     { case 'm':
  3138.       case 'M':
  3139.       { int res, ok;
  3140.         if (!my_read_string ("New value: ") && read_buffer[0])
  3141.         { res = parse_expression (4, read_buffer, &ok);
  3142.           if (ok == ParseError_ok)
  3143.             switch (regs_type[curr])
  3144.             { case 's':
  3145.                 put_undo (®ister_undo, (word32)(regs_addr[curr]),
  3146.                           *regs_addr[curr], 2);
  3147.                 *(unsigned short *)(regs_addr[curr]) = res & 0xffff;
  3148.                 break;
  3149.               case 'f':
  3150.                 put_undo (®ister_undo, 0,
  3151.                           a_tss.tss_eflags, 0);
  3152.                 a_tss.tss_eflags = (a_tss.tss_eflags & ~0xed5) | (res & 0xed5);
  3153.                 break;
  3154.               default:
  3155.                 put_undo (®ister_undo, (word32)(regs_addr[curr]),
  3156.                           *regs_addr[curr], 4);
  3157.                 *regs_addr[curr] = res;
  3158.             }
  3159.           else message (CL_Error, "Bad expression: %s", read_buffer);
  3160.         }
  3161.         break;
  3162.       }        
  3163.       case 'u':
  3164.       case 'U':                                  
  3165.       { word32 u_addr, u_val;
  3166.         int u_size;
  3167.  
  3168.         if (get_undo (®ister_undo, &u_addr, &u_val, &u_size))
  3169.         { switch (u_size)
  3170.           { case 2:      /* 's' */
  3171.               *(unsigned short *)(u_addr) = u_val & 0xffff;
  3172.               break;
  3173.             case 0:      /* 'f' */
  3174.               a_tss.tss_eflags = (a_tss.tss_eflags & ~0xed5) | (u_val & 0xed5);
  3175.               break;
  3176.             case 4:
  3177.               *(word32 *)u_addr = u_val;
  3178.               break;
  3179.           }
  3180.         }
  3181.         break;     
  3182.       }
  3183.     }
  3184.   }
  3185.   if (!(escaped || control_c || control_x))
  3186.     switch (key)
  3187.     { case K_Left:
  3188.       case K_ELeft:
  3189.       case K_Up:
  3190.       case K_EUp:
  3191.       case K_Control_P:
  3192.       case K_Control_B:
  3193.         if (pane_pos > 0)
  3194.           pane_pos--;
  3195.         else if (reg_pane_origin)
  3196.           reg_pane_origin--;
  3197.         break;
  3198.       case K_Right:
  3199.       case K_ERight:
  3200.       case K_Down:
  3201.       case K_EDown:
  3202.       case K_Control_N:
  3203.       case K_Control_F:
  3204.         if (regs_type[pane_pos + reg_pane_origin + 1])
  3205.           if (pane_pos < toplines - 2)
  3206.             pane_pos++;
  3207.           else
  3208.             reg_pane_origin++;
  3209.         break;
  3210.     }
  3211.   redraw (0);
  3212. }
  3213. /* ---------------------------------------------------------------------- */
  3214. static MENU_ITEM Flag_Local_Menu[] = {
  3215.        {"Current      ", 1        , "" , 0},
  3216.        {"~T~oggle flag", ITEM_TYPE, "t", 0},
  3217.        {"~S~et flag   ", ITEM_TYPE, "s", 0},
  3218.        {"~R~eset flag ", ITEM_TYPE, "r", 0},
  3219.        {0              , 0        , "" , 0}
  3220. };                                                     
  3221. /* ---------------------------------------------------------------------- */
  3222. static void
  3223. flag_pane_command (int key)
  3224. { static unsigned flagbits[] =
  3225.     { 0x0001, 0x0004, 0x0010, 0x0040, 0x0080, 0x0200, 0x0400, 0x0800 };
  3226.   int b, curr = pane_pos + flag_pane_origin;
  3227.  
  3228.   if (key == 0)
  3229.   { pop_menu (Flag_Local_Menu, "Flag", cols - 20, 3, &b);
  3230.     switch (b)
  3231.     { case 1:  
  3232.         a_tss.tss_eflags ^= flagbits[curr];
  3233.         break;
  3234.       case 2:
  3235.         a_tss.tss_eflags |= flagbits[curr];
  3236.         break;
  3237.       case 3:
  3238.         a_tss.tss_eflags &= ~flagbits[curr];
  3239.         break;
  3240.     }  
  3241.   }
  3242.   if (!(escaped || control_c || control_x))
  3243.     switch (key)
  3244.     { case K_Left:
  3245.       case K_ELeft:
  3246.       case K_Up:
  3247.       case K_EUp:
  3248.       case K_Control_P:
  3249.       case K_Control_B:
  3250.         if (pane_pos > 0)
  3251.           pane_pos--;
  3252.         else if (flag_pane_origin)
  3253.           flag_pane_origin--;
  3254.         break;
  3255.       case K_Right:
  3256.       case K_ERight:
  3257.       case K_Down:
  3258.       case K_EDown:
  3259.       case K_Control_N:
  3260.       case K_Control_F:
  3261.         if (curr < 7)
  3262.           if (pane_pos < toplines - 2)
  3263.             pane_pos++;
  3264.           else
  3265.             flag_pane_origin++;
  3266.         break;
  3267.     }
  3268.   redraw (0);
  3269. }
  3270. /* ---------------------------------------------------------------------- */
  3271. static MENU_ITEM Breakpoint_Local_Menu[] = {
  3272.        {"Current Highlighted Item          ", 1        , ""    , 0},
  3273.        {"Delete breakpoint             ~^D~", ITEM_TYPE, "\4"  , 0},
  3274.        {"Edit breakpoint               ~^E~", ITEM_TYPE, "\5"  , 0},
  3275.        {"Display Breakpoint                ", ITEM_TYPE, ""    , 0},
  3276.        {"Clear from current breakpoint ~^K~", ITEM_TYPE, "\013", 0},
  3277.        {"Restore breakpoint(s)         ~^Y~", ITEM_TYPE, "\031", 0},
  3278.        {0                                   , 0        , ""    , 0}
  3279. };                                                     
  3280. /* ---------------------------------------------------------------------- */
  3281. static void
  3282. breakpoint_pane_command (int key)
  3283. {
  3284.   int b = breakpoint_count ? pane_pos + breakpoint_origin : -1;
  3285.   int last = breakpoint_count && (b == breakpoint_count - 1);
  3286.   BP_ENTRY *del_bp;
  3287.  
  3288.   if (key == 0)
  3289.   { pop_menu (Breakpoint_Local_Menu, "Breakpoint", cols - 40, rows - 15, &b);
  3290.     control_c = 0;
  3291.     control_x = 0;
  3292.     escaped   = 0;
  3293.     switch (b)
  3294.     { case 1:
  3295.         key = K_Control_D;
  3296.         break;
  3297.       case 2:             
  3298.         key = K_Control_E;
  3299.         break;
  3300.       case 3:             
  3301.         key = K_Return;
  3302.         break;
  3303.       case 4:  
  3304.         key = K_Control_K;
  3305.         break;         
  3306.       case 5:
  3307.         key = K_Control_Y;
  3308.         break;
  3309.     }  
  3310.   }
  3311.   b = breakpoint_count ? pane_pos + breakpoint_origin : -1;
  3312.   if (!(escaped || control_c || control_x))
  3313.     switch (key)
  3314.     { case K_Delete:
  3315.       case K_EDelete:
  3316.       case K_Control_D:
  3317.         if (b != -1)
  3318.           reset_breakpoint (b);
  3319.         if (!last)
  3320.           break;
  3321.         /* else fall through */
  3322.       case K_Left:
  3323.       case K_ELeft:
  3324.       case K_Up:
  3325.       case K_EUp:
  3326.       case K_Control_P:
  3327.       case K_Control_B:
  3328.         if (pane_pos > 0)
  3329.           pane_pos--;
  3330.         else
  3331.           if (breakpoint_origin > 0)
  3332.         breakpoint_origin--;
  3333.         break;
  3334.       case K_Right:
  3335.       case K_ERight:
  3336.       case K_Down:
  3337.       case K_EDown:
  3338.       case K_Control_N:
  3339.       case K_Control_F:
  3340.         if (!last)
  3341.           if (pane_pos < bottomlines / 2 - 1)
  3342.           pane_pos++;
  3343.         else
  3344.           breakpoint_origin++;
  3345.         break;
  3346.       case K_Return:
  3347.         if (b != -1)
  3348.           if (breakpoint_table[b].type == BP_Code)
  3349.           code_pane_goto (breakpoint_table[b].addr);
  3350.           else
  3351.             data_dump_origin = breakpoint_table[b].addr;
  3352.         break;
  3353.       case K_Control_E:
  3354.         if (b != -1)
  3355.           edit_breakpoint(b);
  3356.         break;
  3357.       case K_Control_K:
  3358.       { int temp = breakpoint_count - 1;
  3359.         if (b >= 0)
  3360.           while (temp >= b)
  3361.             reset_breakpoint (temp--);
  3362.         break;
  3363.       }       
  3364.       case K_Control_Y:
  3365.       { word32 u_addr, u_val;
  3366.         int u_size;
  3367.  
  3368.         if (get_undo (&breakpoint_undo, &u_addr, &u_val, &u_size))
  3369.         { del_bp = (BP_ENTRY *)u_val;
  3370.           b = set_breakpoint (del_bp->type, del_bp->length, del_bp->addr);
  3371.           breakpoint_table[b].sub_type = del_bp->sub_type;
  3372.           breakpoint_table[b].count    = del_bp->count;
  3373.           strcpy (breakpoint_table[b].condition, del_bp->condition);
  3374.           free (del_bp);
  3375.         }
  3376.         break;
  3377.       }     
  3378.     }
  3379.   redraw (0);
  3380. }
  3381. /* ---------------------------------------------------------------------- */
  3382. static int
  3383. action_search (DIALOG_ITEM dialog_data[])
  3384. { int size          = *(int *)(dialog_data[0].return_addr);
  3385.   word32 start_at   = *(word32 *)(dialog_data[1].return_addr);
  3386.   word32 search_for = *(word32 *)(dialog_data[2].return_addr);
  3387.   word8  search_byte, *mem_byte;
  3388.   word16 search_word, *mem_word;
  3389.   word32 stop_at,     *mem_long;
  3390.   int i, buf_size, found = 0;
  3391.  
  3392.   stop_at = start_at;
  3393.   if (!size || !valid_addr (start_at, size))
  3394.     return (0);
  3395.   for (i = 0; i < MAX_AREA && !found; i++)
  3396.     if (start_at + size <= areas[i].last_addr &&
  3397.         start_at >= areas[i].first_addr)
  3398.     { stop_at = areas[i].last_addr;
  3399.       found = 1;
  3400.     }
  3401.   if (!found && start_at + size <= dos_mem_hi && start_at >= dos_mem_lo)
  3402.   { stop_at = dos_mem_hi;
  3403.     found = 1;
  3404.   }
  3405.   if (!found)
  3406.     return (0);
  3407.   found = 0;
  3408.   switch (size)
  3409.   { case 1:
  3410.       search_byte = (word8)(search_for & 0xff);
  3411.       do
  3412.       { if (stop_at < start_at + size)
  3413.           break;
  3414.         buf_size = stop_at - start_at;
  3415.         if (buf_size > 4096)
  3416.           buf_size = 4096;
  3417.         read_child (start_at, read_buffer, buf_size);
  3418.         mem_byte = (word8 *)read_buffer;
  3419.         for (i = 0; i < buf_size; i++)
  3420.           if (mem_byte[i] == search_byte)
  3421.           { found = 1;
  3422.             start_at += i;
  3423.             break;
  3424.           }
  3425.         if (!found)
  3426.           start_at += 4096;
  3427.       } while (!found);
  3428.       break;
  3429.     case 2:
  3430.       search_word = (word16)(search_for & 0xffff);
  3431.       do
  3432.       { if (stop_at < start_at + size)
  3433.           break;
  3434.         buf_size = stop_at - start_at;
  3435.         if (buf_size > 4096)
  3436.           buf_size = 4096;
  3437.         read_child (start_at, read_buffer, buf_size);
  3438.         buf_size /= 2;
  3439.         mem_word = (word16 *)read_buffer;
  3440.         for (i = 0; i < buf_size; i++)
  3441.           if (mem_word[i] == search_word)
  3442.           { found = 1;
  3443.             start_at += i * 2;
  3444.             break;
  3445.           }
  3446.         if (!found)
  3447.           start_at += 4096;
  3448.       } while (!found);
  3449.       break;
  3450.     default:
  3451.       size = 4;
  3452.       do
  3453.       { if (stop_at < start_at + size)
  3454.           break;
  3455.         buf_size = stop_at - start_at;
  3456.         if (buf_size > 4096)
  3457.           buf_size = 4096;
  3458.         read_child (start_at, read_buffer, buf_size);
  3459.         buf_size /= 4;
  3460.         mem_long = (word32 *)read_buffer;
  3461.         for (i = 0; i < buf_size; i++)
  3462.           if (mem_long[i] == search_for)
  3463.           { found = 1;
  3464.             start_at += i * 4;
  3465.             break;
  3466.           }
  3467.         if (!found)
  3468.           start_at += 4096;
  3469.       } while (!found);
  3470.       break;
  3471.   }
  3472.   if (!found)
  3473.     return (0);
  3474.   *(word32 *)(dialog_data[1].return_addr) = start_at + size;
  3475.   *(word32 *)(dialog_data[0].return_addr) = size;
  3476.   data_dump_origin = start_at;
  3477.   pane_pos = 0;
  3478.   redraw (0);
  3479.   return (1);
  3480. }
  3481. /* ---------------------------------------------------------------------- */
  3482. static void
  3483. search_memory (void)
  3484. { int size = 1, ret = 2;
  3485.   word32 start_at = areas[A_data].first_addr, search_for = 0;
  3486.  
  3487.   static DIALOG_ITEM dialog_data[] = {
  3488.     {"Size       :", 0 , 03, 1, format_int , eval_word, init_int , editor},
  3489.     {"Start at   :", 0 , 50, 1, format_addr, eval_word, init_addr, editor},
  3490.     {"Search for :", 0 , 10, 1, format_word, eval_word, init_word, editor},
  3491.     {0           , 0 , 0 , 0, 0          , 0        , 0        , 0       }
  3492.   };
  3493.   static BUTTON_ITEM button_data[] = {
  3494.     {" Search ", 1, action_search},
  3495.     {"  Done  ", 0, action_done  },
  3496.     {0         , 0, 0            }
  3497.   };                                               
  3498.  
  3499.   dialog_data[0].return_addr = (word32)&size;
  3500.   dialog_data[1].return_addr = (word32)&start_at;
  3501.   dialog_data[2].return_addr = (word32)&search_for;
  3502.   dialog ("Memory Search", dialog_data, button_data, &ret);
  3503. }
  3504. /* ---------------------------------------------------------------------- */
  3505. static void
  3506. port_io_add_action (DIALOG_ITEM d[], int action,
  3507.                     word32 port, word32 size, word32 data)
  3508. { unsigned char action_id, *p, fmt[ACTION_HIST_SIZE];
  3509.   memcpy ((char *)(d[1].return_addr), (char *)(d[2].return_addr), ACTION_HIST_SIZE);
  3510.   memcpy ((char *)(d[2].return_addr), (char *)(d[3].return_addr), ACTION_HIST_SIZE);
  3511.   memcpy ((char *)(d[3].return_addr), (char *)(d[4].return_addr), ACTION_HIST_SIZE);
  3512.   memcpy ((char *)(d[4].return_addr), (char *)(d[5].return_addr), ACTION_HIST_SIZE);
  3513.   p = (char *)(d[5].return_addr);
  3514.   action_id = p[strlen (p) + 1];
  3515.   action_id++;
  3516.   sprintf (fmt, "%%03d     %%s  0x%%04lx%%-%lds0x%%0%ldlx", 9 - size * 2, size * 2);
  3517.   sprintf (p, fmt, action_id, action ? "Out" : " In", port, " ", data);
  3518.   p[strlen (p) + 1] = action_id;
  3519. }
  3520. /* ---------------------------------------------------------------------- */
  3521. static int
  3522. action_outp (DIALOG_ITEM dialog_data[])
  3523. { int size = *(int *)(dialog_data[6].return_addr);
  3524.   word32 port = *(word32 *)(dialog_data[7].return_addr);
  3525.   word32 data = *(word32 *)(dialog_data[8].return_addr);
  3526.  
  3527.   port &= 0xffff;
  3528.   if (!port || !size)
  3529.     return (0);
  3530.   switch (size)
  3531.   { case 2:
  3532.       data &= 0xffff;
  3533.       outportw (port, data);
  3534.       break;
  3535.     case 4:
  3536.       outportl (port, data);
  3537.       break;
  3538.     default:
  3539.       data &= 0xff;
  3540.       outportb (port, data);
  3541.       break;
  3542.   }
  3543.   port_io_add_action (dialog_data, 1, port, size, data);
  3544.   return (1);
  3545. }
  3546. /* ---------------------------------------------------------------------- */
  3547. static int
  3548. action_inp (DIALOG_ITEM dialog_data[])
  3549. { int size = *(int *)(dialog_data[6].return_addr);
  3550.   word32 port = *(word32 *)(dialog_data[7].return_addr);
  3551.   word32 data;
  3552.  
  3553.   port &= 0xffff;
  3554.   if (!port || !size)
  3555.     return (0);
  3556.   switch (size)
  3557.   { case 2:
  3558.       data = inportw (port) & 0xffff;
  3559.       break;
  3560.     case 4:
  3561.       data = inportl (port);
  3562.       break;
  3563.     default:
  3564.       *(int *)(dialog_data[6].return_addr) = 1;
  3565.       size = 1;
  3566.       data = inportb (port) & 0xff;
  3567.       break;
  3568.   }
  3569.   *(word32 *)(dialog_data[8].return_addr) = data;
  3570.   port_io_add_action (dialog_data, 0, port, size, data);
  3571.   return (1);
  3572. }
  3573. /* ---------------------------------------------------------------------- */
  3574. static void
  3575. read_write_port (void)
  3576. { int ret = 11;
  3577.   static int size = 1;
  3578.   static word32 port = 0x20, data = 0;
  3579.   static char last_act_0[ACTION_HIST_SIZE] = " ID  Action    Port      Value";
  3580.   static char last_act_1[ACTION_HIST_SIZE] = "---     ---  ------ ----------\0";
  3581.   static char last_act_2[ACTION_HIST_SIZE] = "---     ---  ------ ----------\0";
  3582.   static char last_act_3[ACTION_HIST_SIZE] = "---     ---  ------ ----------\0";
  3583.   static char last_act_4[ACTION_HIST_SIZE] = "---     ---  ------ ----------\0";
  3584.   static char last_act_5[ACTION_HIST_SIZE] = "---     ---  ------ ----------\0\377";
  3585.  
  3586.   static DIALOG_ITEM dialog_data[] = {
  3587.     {"History:", 0, 60, 0, format_asis, eval_asis, init_asis, editor},
  3588.     {"        ", 0, 60, 0, format_asis, eval_asis, init_asis, editor},
  3589.     {"        ", 0, 60, 0, format_asis, eval_asis, init_asis, editor},
  3590.     {"        ", 0, 60, 0, format_asis, eval_asis, init_asis, editor},
  3591.     {"        ", 0, 60, 0, format_asis, eval_asis, init_asis, editor},
  3592.     {"        ", 0, 60, 0, format_asis, eval_asis, init_asis, editor},
  3593.     {"Size   :", 0, 03, 1, format_int , eval_word, init_int , editor},
  3594.     {"Port   :", 0, 10, 1, format_word, eval_word, init_word, editor},
  3595.     {"Data   :", 0, 10, 1, format_word, eval_word, init_word, editor},
  3596.     {0         , 0, 0 , 0, 0          , 0        , 0        , 0     }
  3597.   };
  3598.   static BUTTON_ITEM button_data[] = {
  3599.     {"  Out   ", 1, action_outp},
  3600.     {"   In   ", 1, action_inp },
  3601.     {"  Done  ", 0, action_done},
  3602.     {0         , 0, 0          }
  3603.   };                                               
  3604.  
  3605.   dialog_data[0].return_addr = (word32)last_act_0;
  3606.   dialog_data[1].return_addr = (word32)last_act_1;
  3607.   dialog_data[2].return_addr = (word32)last_act_2;
  3608.   dialog_data[3].return_addr = (word32)last_act_3;
  3609.   dialog_data[4].return_addr = (word32)last_act_4;
  3610.   dialog_data[5].return_addr = (word32)last_act_5;
  3611.   dialog_data[6].return_addr = (word32)&size;
  3612.   dialog_data[7].return_addr = (word32)&port;
  3613.   dialog_data[8].return_addr = (word32)&data;
  3614.   dialog ("Port IO", dialog_data, button_data, &ret);
  3615. }
  3616. /* ---------------------------------------------------------------------- */
  3617. static MENU_ITEM Data_Local_Menu[] = {
  3618.        {"Current Highlighted Item            ", 1        , ""     , 0},
  3619.        {"Toggle data write breakpoint     ~w~", ITEM_TYPE, "w"    , 0},
  3620.        {"Toggle read/write breakpoint     ~r~", ITEM_TYPE, "r"    , 0},
  3621.        {"Display data at EIP              ~i~", ITEM_TYPE, "i"    , 0},
  3622.        {"Display data at ESP              ~s~", ITEM_TYPE, "s"    , 0},
  3623.        {"Display data at current pointer  ~*~", ITEM_TYPE, "*"    , 0},
  3624.        {"Display data at last address(es) ~@~", ITEM_TYPE, "@"    , 0},
  3625.        {"Move pane's origin left        ~M b~", ITEM_TYPE, "\033b", 0},
  3626.        {"Move pane's origin right       ~M f~", ITEM_TYPE, "\033f", 0},
  3627.        {"Display as bytes                 ~b~", ITEM_TYPE, "b"    , 0},
  3628.        {"Display as words                 ~h~", ITEM_TYPE, "h"    , 0},
  3629.        {"Display as dwords                ~f~", ITEM_TYPE, "f"    , 0},
  3630.        {"Port access                      ~p~", ITEM_TYPE, "p"    , 0},
  3631.        {"Modify data at cursor         ~^C m~", ITEM_TYPE, "\3m"  , 0},
  3632.        {"Undo modification(s)          ~^C u~", ITEM_TYPE, "\3u"  , 0},
  3633.        {"Search memory                 ~^C s~", ITEM_TYPE, "\3s"  , 0},
  3634.        {"Data structure supports          ~n~", ITEM_TYPE, "n"    , 0},
  3635.        {0                                     , 0        , ""     , 0}
  3636. };                                        
  3637. static word32 old_dump_address[5] = {0, 0, 0, 0, 0};
  3638. /* ---------------------------------------------------------------------- */
  3639. static void
  3640. data_pane_command (int key)
  3641. { word32 v = data_dump_origin + pane_pos;
  3642.   int res, ok, bad = 0;
  3643.   char *p, *p0, q, s[2];
  3644.   
  3645.   if (key == 0)
  3646.   { pop_menu (Data_Local_Menu, "Data", 1, rows - 19, &res);
  3647.     control_c = 0;
  3648.     control_x = 0;
  3649.     escaped   = 0;
  3650.     switch (res)
  3651.     { case 1: 
  3652.         key = 'w';
  3653.         break;
  3654.       case 2:        
  3655.         key = 'r';
  3656.         break;
  3657.       case 3:        
  3658.         key = 'i';
  3659.         break;
  3660.       case 4:        
  3661.         key = 's';
  3662.         break;
  3663.       case 5:        
  3664.         key = '*';
  3665.         break;
  3666.       case 6:        
  3667.         key = '@';
  3668.         break;
  3669.       case 7:    
  3670.         escaped = 1;    
  3671.         key = 'b';
  3672.         break;
  3673.       case 8:        
  3674.         escaped = 1;    
  3675.         key = 'f';
  3676.         break;
  3677.       case 9:        
  3678.         key = 'b';
  3679.         break;
  3680.       case 10:        
  3681.         key = 'h';
  3682.         break;
  3683.       case 11:        
  3684.         key = 'f';
  3685.         break;
  3686.       case 12:        
  3687.         key = 'p';
  3688.         break;
  3689.       case 13:   
  3690.         control_c = 1;
  3691.         key = 'm';
  3692.         break;
  3693.       case 14:
  3694.         control_c = 1;
  3695.         key = 'u';
  3696.         break;
  3697.     case 15:
  3698.         control_c = 1;
  3699.         key = 's';
  3700.     case 16:
  3701.         key = 'n';
  3702.         break;
  3703.     }
  3704.   }
  3705.   if (control_x)
  3706.   { switch (key)
  3707.     { case '/':                            /* Save to register      */
  3708.         key = my_get_char ("Save address to which register (0..A..z)? ");
  3709.         if (key >= '0' && key <= 'z')
  3710.            registers[key - '0'] = v;
  3711.         break;
  3712.       case 'j':                            /* Load from register    */
  3713.       case 'J':       
  3714.         key = my_get_char ("Load address from which register (0..A..z)? ");
  3715.         if (key >= '0' && key <= 'z')
  3716.           if (registers[key - '0'])
  3717.           { data_dump_origin = registers[key - '0'];
  3718.             pane_pos = 0;
  3719.           }
  3720.         break;
  3721.     }           
  3722.   }                                                
  3723.   if (control_c)
  3724.   { switch (key)
  3725.     { case 'm':
  3726.       case 'M':
  3727.       { if (!my_read_string ("New value: "))
  3728.         { p = read_buffer;
  3729.           do
  3730.           { while (*p == ' ') p++;
  3731.             switch (*p)
  3732.             { case '\0':
  3733.                 break;
  3734.               case '\'':
  3735.               case '"':
  3736.                 if (data_dump_size != 1)
  3737.                 { *p = 0;
  3738.                   message (CL_Error, "Strings must be entered in byte mode");
  3739.                   break;
  3740.                 }
  3741.                 q = *p++;
  3742.                 p0 = p;
  3743.                 while (*p != q && *p) 
  3744.                   p++;
  3745.                 if (*p)
  3746.                 { while (p0 != p)
  3747.                   { if (valid_addr (v, 1))
  3748.                       write_child (v, p0, 1);
  3749.                     else
  3750.                       bad = 1;
  3751.                     p0++, v++;
  3752.                   }
  3753.                   if (q == '"')
  3754.                   { if (valid_addr (v, 1))
  3755.                     { q = 0;
  3756.                       write_child (v, &q, 1);
  3757.                       q = '"';
  3758.                     }
  3759.                     else
  3760.                       bad = 1;
  3761.                     v++;
  3762.                   }
  3763.                   p++;
  3764.                 }
  3765.                 else
  3766.                   message (CL_Error, "String constant not terminated");
  3767.                 break;
  3768.               default:
  3769.                 p0 = p;
  3770.                 while (*p != ',' && *p)
  3771.                   p++;
  3772.                 q = *p;
  3773.                 *p = 0;
  3774.                 res = parse_expression (4, p0, &ok);
  3775.                 if (ok == ParseError_ok)
  3776.                 { *p = q;
  3777.                   if (valid_addr (v, data_dump_size))
  3778.                   { word32 u_val;
  3779.                     read_child (v, &u_val, data_dump_size);
  3780.                     put_undo (&data_undo, v, u_val, data_dump_size);
  3781.                     write_child (v, &res, data_dump_size);
  3782.                   } else
  3783.                     bad = 1;
  3784.                   v += data_dump_size;
  3785.                 } else
  3786.                 { message (CL_Error, "Invalid expression: %s", p0);
  3787.                   bad = 1;
  3788.                 }
  3789.             }
  3790.             if (*p == ',') 
  3791.               p++;
  3792.           } while (*p);
  3793.           if (bad)
  3794.             message (CL_Error, "Part of the data could not be written");
  3795.           else
  3796.             message (CL_Info, "Memory modified.");
  3797.         }
  3798.         break;
  3799.       } 
  3800.       case 'u':
  3801.       case 'U':                                                     
  3802.       { word32 u_addr, u_val, old_val = 0;
  3803.         int u_size;
  3804.  
  3805.         if (get_undo (&data_undo, &u_addr, &u_val, &u_size))
  3806.         { read_child  (u_addr, &old_val, u_size);
  3807.           write_child (u_addr, &u_val, u_size);  
  3808.           message (CL_Msg, 
  3809.                    "%d byte(s) at %08lx has been undone from %08lx to %08lx",
  3810.                    u_size, u_addr, old_val, u_val);
  3811.         }
  3812.         break;     
  3813.       }
  3814.       case 's':
  3815.       case 'S':
  3816.          search_memory ();
  3817.          break;
  3818.     }
  3819.   }
  3820.   if (escaped)
  3821.   { switch (key)
  3822.     { case 'b':
  3823.       case 'B':
  3824.         data_dump_origin--;
  3825.         break;
  3826.       case 'f':
  3827.       case 'F':
  3828.         data_dump_origin++;
  3829.         break; 
  3830.       case 'v':
  3831.       case 'V':
  3832.         escaped = 0;
  3833.         key = K_PageUp;
  3834.         break;
  3835.     }
  3836.   }
  3837.   if (!(escaped || control_c || control_x))
  3838.     switch (key)
  3839.     { case K_Up:
  3840.       case K_EUp:
  3841.       case K_Control_P:
  3842.         if (pane_pos >= 8)
  3843.           pane_pos -= 8;
  3844.         else
  3845.           data_dump_origin -= 8;
  3846.         break;
  3847.       case K_Down:
  3848.       case K_EDown:
  3849.       case K_Control_N:
  3850.         if (v + 8 <= data_dump_last)
  3851.           pane_pos += 8;
  3852.         else
  3853.           data_dump_origin += 8;
  3854.         break;
  3855.       case K_Left:
  3856.       case K_ELeft:
  3857.       case K_Control_B:
  3858.         if (pane_pos > 0)
  3859.           pane_pos -= data_dump_size;
  3860.         else
  3861.           data_dump_origin -= 8, pane_pos = 8 - data_dump_size;
  3862.         break;
  3863.       case K_Right:
  3864.       case K_ERight:
  3865.       case K_Control_F:
  3866.         if (v + data_dump_size <= data_dump_last)
  3867.           pane_pos += data_dump_size;
  3868.         else
  3869.           data_dump_origin += 8, pane_pos -= (8 - data_dump_size);
  3870.         break;
  3871.       case K_PageUp:
  3872.       case K_EPageUp:
  3873.         data_dump_origin -= (data_dump_last + 1 - data_dump_origin);
  3874.         break;
  3875.       case K_PageDown:
  3876.       case K_EPageDown:
  3877.       case K_Control_V:
  3878.         data_dump_origin = data_dump_last + 1;
  3879.         break;
  3880.       case 's':
  3881.       case 'S':
  3882.         data_dump_origin = a_tss.tss_esp;
  3883.         pane_pos = 0;
  3884.         break;
  3885.       case 'i':
  3886.       case 'I':
  3887.         data_dump_origin = a_tss.tss_eip;
  3888.         data_dump_size = 1;
  3889.         pane_pos = 0;
  3890.         break;                     
  3891.       case '*':  
  3892.         if (valid_addr (v, 4))
  3893.         { for (res = 1; res < 5; res++)
  3894.             old_dump_address[res - 1] = old_dump_address[res];
  3895.           old_dump_address[4] = data_dump_origin + pane_pos;
  3896.           read_child (v, &data_dump_origin, 4);
  3897.           pane_pos = 0;
  3898.         } else
  3899.           message (CL_Error, "Pointer points to an invalid address.");
  3900.         break;
  3901.       case '@':
  3902.         if (!old_dump_address[4])
  3903.            old_dump_address[4] = data_dump_origin;
  3904.         data_dump_origin = old_dump_address[4]; 
  3905.         pane_pos = 0;
  3906.         for (res = 4; res > 0; res--)
  3907.            old_dump_address[res] = old_dump_address[res - 1];
  3908.         old_dump_address[0] = data_dump_origin;
  3909.         break;
  3910.       case 'b':
  3911.       case 'B':
  3912.         data_dump_size = 1;
  3913.         break;
  3914.       case 'h':
  3915.       case 'H':
  3916.         data_dump_size = 2;
  3917.         break;
  3918.       case 'f':
  3919.       case 'F':
  3920.         data_dump_size = 4;
  3921.         break;
  3922.       case 'n':
  3923.       case 'N':               
  3924.         if (!running_xsupport)
  3925.         { running_xsupport = 1;
  3926.           if (extern_data_support(v))
  3927.             running_xsupport = 0;
  3928.           break;
  3929.         }
  3930.       case 'p':
  3931.       case 'P':
  3932.         read_write_port();
  3933.         break;
  3934.       case 'w':
  3935.       case 'W':
  3936.         res = get_breakpoint (BP_Write, data_dump_size, v);
  3937.         if (res == -1)
  3938.           set_breakpoint (BP_Write, data_dump_size, v);
  3939.         else
  3940.           reset_breakpoint (res);
  3941.         break;
  3942.       case 'r':
  3943.       case 'R':
  3944.         res = get_breakpoint (BP_Read, data_dump_size, v);
  3945.         if (res == -1)
  3946.           set_breakpoint (BP_Read, data_dump_size, v);
  3947.         else
  3948.           reset_breakpoint (res);
  3949.         break;
  3950.       case 'e':
  3951.       case 'E':
  3952.         res = get_breakpoint (BP_Read, -1, v);
  3953.         if (res == -1)
  3954.         { res = set_breakpoint (BP_Read, data_dump_size, v);
  3955.           if (edit_breakpoint(res))
  3956.             reset_breakpoint (res);
  3957.         } else
  3958.           edit_breakpoint (res);
  3959.         break;
  3960.       default:
  3961.         if ((key == '_') || (key == '%') ||
  3962.             (key == '(') || (key >= '0' && key <= '9'))
  3963.         { s[0] = key; s[1] = '\0';
  3964.           if (last_addr[0])
  3965.             ok = !read_string (last_addr);
  3966.           else
  3967.             ok = !read_string (key == '=' ? "" : s);
  3968.           strcpy (last_addr, read_buffer);
  3969.           if (ok)
  3970.           { p = read_buffer;
  3971.             while (*p != 0 && *p == ' ')
  3972.               p++;
  3973.             if (*p)
  3974.             { res = parse_expression (4, p, &ok);
  3975.               if (ok == ParseError_ok)
  3976.               { data_dump_origin = res;
  3977.                 pane_pos = 0;
  3978.                 for (res = 1; res < 5; res++)
  3979.                   old_dump_address[res - 1] = old_dump_address[res];
  3980.                 old_dump_address[4] = data_dump_origin;
  3981.                 last_addr[0] = 0;
  3982.                 message (CL_Info, "Found address %s.", p);
  3983.               }                                  
  3984.               else
  3985.                 message (CL_Error, "Bad address: %s", p);
  3986.             }
  3987.           }
  3988.         }
  3989.         break;
  3990.       }
  3991.   pane_pos &= ~(data_dump_size - 1);
  3992.   redraw (0);
  3993. }
  3994. /* ---------------------------------------------------------------------- */
  3995. static MENU_ITEM Npx_Local_Menu[] = {
  3996.        {"Current Item            ", 1        , ""   , 0},
  3997.        {"Empty register    ~^C e~", ITEM_TYPE, "\3e", 0},
  3998.        {"Zero register     ~^C z~", ITEM_TYPE, "\3z", 0},
  3999.        {"Negate register   ~^C n~", ITEM_TYPE, "\3n", 0},
  4000.        {"Modify register   ~^C m~", ITEM_TYPE, "\3m", 0},
  4001.        {"Undo modification ~^C u~", ITEM_TYPE, "\3u", 0},
  4002.        {0                         , 0        , ""   , 0}
  4003. };                                                     
  4004. /* ---------------------------------------------------------------------- */
  4005. static void
  4006. npx_pane_command (int key)
  4007. { NPX *del_npx;
  4008.   int reg = pane_pos - 3, rotreg = 0, tag = 0;
  4009.   int regp = (reg >= 0);
  4010.   int b;
  4011.  
  4012.   save_npx ();      
  4013.   if (regp)
  4014.   { rotreg = (reg + (npx.status >> 11)) & 7;
  4015.     tag = (npx.tag >> (rotreg * 2)) & 3;
  4016.   }
  4017.  
  4018.   if (key == 0)
  4019.   { pop_menu (Npx_Local_Menu, "Npx", 1, 3, &b);
  4020.     control_c = 1;
  4021.     control_x = 0;
  4022.     escaped   = 0;
  4023.     switch (b)
  4024.     { case 1:
  4025.         key = 'e';
  4026.         break;
  4027.       case 2:             
  4028.         key = 'z';
  4029.         break;
  4030.       case 3:             
  4031.         key = 'n';
  4032.         break;
  4033.       case 4:    
  4034.         key = 'm';
  4035.         break;
  4036.       case 5:    
  4037.         key = 'u';
  4038.         break;
  4039.     }                                      
  4040.   }           
  4041.   if (control_c)
  4042.   { switch (key)
  4043.     { case 'e':
  4044.       case 'E':
  4045.         if (regp)
  4046.         { tag = 3;                     
  4047.           del_npx = malloc (sizeof (NPX));
  4048.           memcpy (del_npx, &npx, sizeof (NPX));
  4049.           put_undo (&npx_undo, 1, (word32)del_npx, 1);
  4050.       memset (&npx.reg[reg], 0, sizeof (NPXREG));
  4051.     }
  4052.         break;
  4053.       case 'z':
  4054.       case 'Z':
  4055.         if (regp)
  4056.         { tag = 1;
  4057.           del_npx = malloc (sizeof (NPX));
  4058.           memcpy (del_npx, &npx, sizeof (NPX));
  4059.           put_undo (&npx_undo, 1, (word32)del_npx, 1);
  4060.       memset (&npx.reg[reg], 0, sizeof (NPXREG));
  4061.     }
  4062.         break;
  4063.       case 'n':
  4064.       case 'N':
  4065.         if (regp)
  4066.         { del_npx = malloc (sizeof (NPX));
  4067.           memcpy (del_npx, &npx, sizeof (NPX));
  4068.           put_undo (&npx_undo, 1, (word32)del_npx, 1);
  4069.           npx.reg[reg].sign = !npx.reg[reg].sign;
  4070.         }
  4071.         break;
  4072.       case 'm':
  4073.       case 'M':
  4074.       { char *p, *endp;
  4075.         double d;
  4076.  
  4077.         if (!my_read_string ("New value: "))
  4078.         { p = read_buffer;
  4079.           del_npx = malloc (sizeof (NPX));
  4080.           memcpy (del_npx, &npx, sizeof (NPX));
  4081.           put_undo (&npx_undo, 1, (word32)del_npx, 1);
  4082.           while (*p == ' ')
  4083.             p++;
  4084.           if (*p == '\0')
  4085.             break;
  4086.           strlwr (p);
  4087.           if (strcmp (p, "+inf") == 0
  4088.               || strcmp (p, "inf") == 0
  4089.               || strcmp (p, "-inf") == 0)
  4090.           { tag = 2;
  4091.             npx.reg[reg].exponent = 0x7fff;
  4092.             npx.reg[reg].sig3 = 0x8000;
  4093.             npx.reg[reg].sig2
  4094.             = npx.reg[reg].sig1
  4095.             = npx.reg[reg].sig0 = 0;
  4096.             npx.reg[reg].sign = (*p == '-');
  4097.           } else
  4098.           { d = strtod (p, &endp);
  4099.             if (*p != '\0' && *endp)
  4100.               message (CL_Error, "Expression not understood");
  4101.             else
  4102.             { tag = (d == 0.0);
  4103.               *((long double *)(npx.reg + reg)) = (long double) d;
  4104.               npx.reg[reg].sign = (*p == '-'); /* for -Zero */
  4105.             }
  4106.           }
  4107.         }
  4108.         break;
  4109.       }
  4110.       case 'u':
  4111.       case 'U':
  4112.       { word32 u_addr, u_val;
  4113.         int u_size;
  4114.         if (get_undo (&npx_undo, &u_addr, &u_val, &u_size))
  4115.         { del_npx = (NPX *)u_val;
  4116.           memcpy (&npx, del_npx, sizeof (NPX));
  4117.         }
  4118.         break;                                             
  4119.       }
  4120.     }
  4121.   }
  4122.   if (!(escaped || control_c || control_x))
  4123.     switch (key)
  4124.     { case K_Left:
  4125.       case K_ELeft:
  4126.       case K_Up:
  4127.       case K_EUp:
  4128.       case K_Control_P:
  4129.       case K_Control_B:
  4130.         if (pane_pos > 0) pane_pos--;
  4131.         break;
  4132.       case K_Right:
  4133.       case K_ERight:
  4134.       case K_Down:
  4135.       case K_EDown:    
  4136.       case K_Control_N:
  4137.       case K_Control_F:
  4138.         if ((pane_pos < 10) && (pane_pos < toplines - 2)) pane_pos++;
  4139.         break;
  4140.     }
  4141.   if (regp)
  4142.     npx.tag = (npx.tag & ~(3 << (rotreg * 2))) | (tag << (rotreg * 2));
  4143.   load_npx ();
  4144.   redraw (0);
  4145. }
  4146. /* ---------------------------------------------------------------------- */
  4147. static MENU_ITEM Stack_Local_Menu[] = {
  4148.        {"Current Highlighted", 1        , ""    , 0},
  4149.        {"Goto function  ~^M~", ITEM_TYPE, "\015", 0},
  4150.        {0                    , 0        , ""    , 0}
  4151. };                                                     
  4152. /* ---------------------------------------------------------------------- */
  4153. static void
  4154. stack_pane_command (int key)
  4155. {
  4156.   int b;
  4157.  
  4158.   if (key == 0)
  4159.   { pop_menu (Stack_Local_Menu, "Stack", 1, 3, &b);
  4160.     control_c = 0;
  4161.     control_x = 0;
  4162.     escaped   = 0;
  4163.     switch (b)
  4164.     { case 1:
  4165.         key = K_Return;
  4166.         break;
  4167.     }  
  4168.   }
  4169.   if (!(escaped || control_c || control_x))
  4170.     switch (key)
  4171.     { case K_Left:
  4172.       case K_ELeft:
  4173.       case K_Up:
  4174.       case K_EUp:
  4175.       case K_Control_P:
  4176.       case K_Control_B:
  4177.         if (pane_pos > 0)
  4178.           pane_pos--;
  4179.         else
  4180.           if (stack_dump_origin)
  4181.             stack_dump_origin--;
  4182.         break;
  4183.       case K_Right:
  4184.       case K_ERight:
  4185.       case K_Down:
  4186.       case K_EDown:
  4187.       case K_Control_N:
  4188.       case K_Control_F:
  4189.         if (pane_pos < stack_dump_last)
  4190.           pane_pos++;
  4191.         else
  4192.           if (stack_dump_more)
  4193.             stack_dump_origin++;
  4194.         break;
  4195.       case K_Return:
  4196.         code_pane_goto (stack_dump_pos[pane_pos]);
  4197.         stack_pane_active = 0;
  4198.         code_pane_active = 1;
  4199.         pane = 0;
  4200.         break;
  4201.     }
  4202.   redraw (0);
  4203. }
  4204. /* ---------------------------------------------------------------------- */
  4205. static MENU_ITEM Info_Local_Menu[] = {
  4206.        {"Current Highlighted Item", 1        , "", 0},
  4207.        {"No command available    ", ITEM_TYPE, "", 0},
  4208.        {0                         , 0        , "", 0}
  4209. };                                                     
  4210. /* ---------------------------------------------------------------------- */
  4211. static void
  4212. info_pane_command (int key)
  4213. { int b;
  4214.   /* No keys recognized.  */
  4215.         
  4216.   if (key == 0)
  4217.   { pop_menu (Info_Local_Menu, "Info", 1, 3, &b);
  4218.   }
  4219.   redraw (0);
  4220. }
  4221. /* ---------------------------------------------------------------------- */
  4222. static void
  4223. fullscr_listwild_handler (word32 sym_num)
  4224. { whereis_pane_sym = realloc (whereis_pane_sym,
  4225.                  (++whereis_sym_count) * sizeof (word32));
  4226.   whereis_pane_sym[whereis_sym_count - 1] = sym_num;
  4227. }
  4228. /* ---------------------------------------------------------------------- */
  4229. static void
  4230. init_whereis_sym (void)
  4231. { char *p;
  4232.  
  4233.   if (!my_read_string ("Search for: ") && read_buffer[0] != '\0')
  4234.   { whereis_pane_sym = realloc (whereis_pane_sym, 0);
  4235.     p = read_buffer;
  4236.     while (*p == ' ') p++;
  4237.     syms_listwild (p, &fullscr_listwild_handler);
  4238.     pane_pos = whereis_origin = 0;
  4239.     if (whereis_sym_count >= 10)
  4240.       message (CL_Info, "There were %d symbols that matched",
  4241.                 whereis_sym_count);
  4242.   }        
  4243.   redraw (0);
  4244. }
  4245. /* ---------------------------------------------------------------------- */
  4246. static MENU_ITEM WhereIs_Local_Menu[] = {
  4247.        {"Current Highlighted Item    ", 1        , ""     , 0},
  4248.        {"Goto beginning of list ~M <~", ITEM_TYPE, "\033<", 0},
  4249.        {"Goto end of list       ~M >~", ITEM_TYPE, "\033>", 0},
  4250.        {"Search for symbol(s)        ", ITEM_TYPE, ""     , 0},
  4251.        {0                             , 0        , ""     , 0}
  4252. };                                                     
  4253. /* ---------------------------------------------------------------------- */
  4254. static void
  4255. whereis_pane_command (int key)
  4256. {
  4257.   int no = whereis_origin + pane_pos;
  4258.   int b;
  4259.  
  4260.   if (key == 0)
  4261.   { pop_menu (WhereIs_Local_Menu, "WhereIs", 1, 3, &b);
  4262.     control_c = 0;
  4263.     control_x = 0;
  4264.     escaped   = 0;
  4265.     switch (b)
  4266.     { case 1:
  4267.         key = K_Home;
  4268.         break;
  4269.       case 2:             
  4270.         key = K_End;
  4271.         break;
  4272.       case 3:
  4273.         key = '_';
  4274.         break;
  4275.     }  
  4276.   }
  4277.   if (escaped)
  4278.   { switch (key)
  4279.     { case 'v':
  4280.       case 'V':
  4281.         escaped = 0;
  4282.         key = K_PageUp;
  4283.         break;
  4284.       case '>':
  4285.         escaped = 0;
  4286.         key = K_End;
  4287.         break;
  4288.       case '<':
  4289.         escaped = 0;
  4290.         key = K_Home;
  4291.         break;
  4292.     }
  4293.   }
  4294.   if (!(escaped || control_c || control_x))
  4295.   { switch (key)
  4296.     { case K_Left:
  4297.       case K_ELeft:
  4298.       case K_Up:
  4299.       case K_EUp:   
  4300.       case K_Control_P:
  4301.       case K_Control_B:
  4302.         if (pane_pos > 0)
  4303.           pane_pos--;
  4304.         else
  4305.           if (whereis_origin)
  4306.             whereis_origin--;
  4307.         break;
  4308.       case K_Right:
  4309.       case K_ERight:
  4310.       case K_Down:
  4311.       case K_EDown:    
  4312.       case K_Control_N:
  4313.       case K_Control_F:
  4314.         if (no < whereis_sym_count - 1)
  4315.           if (pane_pos < toplines - 2)
  4316.             pane_pos++;
  4317.         else
  4318.             whereis_origin++;
  4319.         break;
  4320.       case K_Home:
  4321.       case K_EHome:
  4322.         pane_pos = whereis_origin = 0;
  4323.         break;
  4324.       case K_End:
  4325.       case K_EEnd:
  4326.         if (whereis_sym_count > toplines - 1)
  4327.         { whereis_origin = whereis_sym_count - toplines;
  4328.           pane_pos = toplines - 2;
  4329.         }
  4330.         else
  4331.         { whereis_origin = 0;
  4332.           pane_pos = whereis_sym_count ? whereis_sym_count - 1 : 0;
  4333.         }
  4334.         break;
  4335.       case K_PageDown:
  4336.       case K_EPageDown:
  4337.       case K_Control_V:
  4338.         if (whereis_origin + toplines < whereis_sym_count)
  4339.         { whereis_origin += toplines - 1;
  4340.           if (whereis_origin + pane_pos >= whereis_sym_count)
  4341.           pane_pos = whereis_sym_count - 1 - whereis_origin;
  4342.         }
  4343.         break;
  4344.       case K_PageUp:
  4345.       case K_EPageUp:
  4346.         if (whereis_origin > toplines)
  4347.           whereis_origin -= toplines;
  4348.         else
  4349.           whereis_origin = pane_pos = 0;
  4350.         break;
  4351.       case K_Return:
  4352.         if (whereis_sym_count)
  4353.         { char typ;
  4354.           unsigned long ul;
  4355.  
  4356.           syms_get (whereis_pane_sym[no], &ul, &typ);
  4357.           switch (toupper (typ))
  4358.           { case 'T':
  4359.               code_pane_goto (ul);
  4360.               whereis_pane_active = 0;
  4361.               code_pane_active = 1;
  4362.               pane = 0;
  4363.               break;
  4364.             case 'B':
  4365.             case 'D':
  4366.              data_dump_origin = ul;
  4367.              pane_positions[4] = 0;
  4368.              break;
  4369.           }
  4370.         }
  4371.         break;
  4372.       default:
  4373.         if ((key == '_') || (key >= '0' && key <= '9'))
  4374.         { char s[2], *p;
  4375.  
  4376.           s[0] = key; s[1] = '\0';
  4377.           if (!read_string (key == '=' ? "" : s) && read_buffer[0] != '\0')
  4378.           { whereis_pane_sym = realloc (whereis_pane_sym, 0);
  4379.             whereis_sym_count = 0;
  4380.             p = read_buffer;
  4381.             while (*p == ' ') p++;
  4382.             syms_listwild (p, &fullscr_listwild_handler);
  4383.             pane_pos = whereis_origin = 0;
  4384.             if (whereis_sym_count >= 10)
  4385.               message (CL_Info, "There were %d symbols that matched",
  4386.                        whereis_sym_count);
  4387.           }
  4388.         }
  4389.     }
  4390.   }
  4391.   redraw (0);
  4392. }
  4393. /* ---------------------------------------------------------------------- */
  4394. static MENU_ITEM Module_Local_Menu[] = {
  4395.        {"Current Highlighted Item", 1        , "", 0},
  4396.        {"No command available    ", ITEM_TYPE, "", 0},
  4397.        {0                         , 0        , "", 0}
  4398. };                                                     
  4399. /* ---------------------------------------------------------------------- */
  4400. static void
  4401. module_pane_command(int key)
  4402. {
  4403.   int no = module_origin + pane_pos;
  4404.   int b;
  4405.  
  4406.   if (key == 0)
  4407.   { pop_menu (Module_Local_Menu, "Module", 1, 3, &b);
  4408.   }
  4409.   if (escaped)
  4410.   { switch (key)
  4411.     { case 'v':
  4412.       case 'V':
  4413.         escaped = 0;
  4414.         key = K_PageUp;
  4415.         break;
  4416.       case '>':
  4417.         escaped = 0;
  4418.         key = K_End;
  4419.         break;
  4420.       case '<':
  4421.         escaped = 0;
  4422.         key = K_Home;
  4423.         break;
  4424.     }
  4425.   }
  4426.   if (!(escaped || control_c || control_x))
  4427.   { switch (key)
  4428.     { case K_Left:
  4429.       case K_ELeft:
  4430.       case K_Up:
  4431.       case K_EUp:
  4432.         if (pane_pos > 0)
  4433.           pane_pos--;
  4434.         else
  4435.           if (module_origin)
  4436.             module_origin--;
  4437.         break;
  4438.       case K_Right:
  4439.       case K_ERight:
  4440.       case K_Down:
  4441.       case K_EDown:
  4442.         if (no < module_text_count - 1)
  4443.           if (pane_pos < toplines - 2)
  4444.             pane_pos++;
  4445.           else
  4446.             module_origin++;
  4447.         break;
  4448.       case K_Home:
  4449.       case K_EHome:
  4450.         pane_pos = module_origin = 0;
  4451.         break;
  4452.       case K_End:
  4453.       case K_EEnd:
  4454.         if (module_text_count > toplines - 1)
  4455.         { module_origin = module_text_count - toplines;
  4456.           pane_pos = toplines - 2;
  4457.         }
  4458.         else
  4459.         { module_origin = 0;
  4460.           pane_pos = module_text_count ? module_text_count - 1 : 0;
  4461.         }
  4462.         break;
  4463.       case K_PageDown:
  4464.       case K_EPageDown:
  4465.       case K_Control_V:
  4466.         if (module_origin + toplines <= module_text_count)
  4467.         { module_origin += toplines - 1;
  4468.           if (module_origin + pane_pos >= module_text_count)
  4469.             pane_pos = module_text_count - 1 - module_origin;
  4470.         }
  4471.         break;
  4472.       case K_PageUp:
  4473.       case K_EPageUp:
  4474.         if (module_origin > toplines - 1)
  4475.           module_origin -= toplines - 1;
  4476.         else
  4477.           module_origin = pane_pos = 0;
  4478.         break;
  4479.       case K_Return:
  4480.         if (no)
  4481.           if (!my_read_string ("Line number: "))
  4482.           { unsigned long ul;
  4483.             char *endp;
  4484.   
  4485.             ul = strtoul (read_buffer, &endp, 0);
  4486.             ul = get_linenum (no - 1, ul);
  4487.             code_pane_goto (ul);
  4488.             module_pane_active = 0;
  4489.             code_pane_active = 1;
  4490.             pane = 0;
  4491.           }
  4492.         break;
  4493.       case K_Control_G:
  4494.         module_pane_active = 0;
  4495.         code_pane_active = 1;
  4496.         pane = 0;
  4497.         break;
  4498.     }
  4499.   }
  4500.   redraw (0);
  4501. }
  4502. /* ---------------------------------------------------------------------- */
  4503. static MENU_ITEM Help_Local_Menu[] = {
  4504.        {"Current Highlighted Item", 1        , "", 0},
  4505.        {"No command available    ", ITEM_TYPE, "", 0},
  4506.        {0                         , 0        , "", 0}
  4507. };                                                     
  4508. /* ---------------------------------------------------------------------- */
  4509. static void
  4510. help_pane_command(int key)
  4511. {
  4512.   int no = help_origin + pane_pos;
  4513.   int b;
  4514.  
  4515.   if (key == 0)
  4516.   { pop_menu (Help_Local_Menu, "Help", 1, 3, &b);
  4517.   }
  4518.   if (escaped)
  4519.   { switch (key)
  4520.     { case 'v':
  4521.       case 'V':
  4522.         escaped = 0;
  4523.         key = K_PageUp;
  4524.         break;
  4525.       case '>':
  4526.         escaped = 0;
  4527.         key = K_End;
  4528.         break;
  4529.       case '<':
  4530.         escaped = 0;
  4531.         key = K_Home;
  4532.         break;
  4533.     }
  4534.   }
  4535.   if (!(escaped || control_c || control_x))
  4536.   { switch (key)
  4537.     { case K_Left:
  4538.       case K_ELeft:
  4539.       case K_Up:
  4540.       case K_EUp:
  4541.       case K_Control_P:
  4542.       case K_Control_B:
  4543.         if (pane_pos > 0)
  4544.           pane_pos--;
  4545.         else
  4546.           if (help_origin)
  4547.             help_origin--;
  4548.         break;
  4549.       case K_Right:
  4550.       case K_ERight:
  4551.       case K_Down:
  4552.       case K_EDown:    
  4553.       case K_Control_N:
  4554.       case K_Control_F:
  4555.         if (no < help_text_count - 1)
  4556.           if (pane_pos < toplines - 2)
  4557.             pane_pos++;
  4558.           else
  4559.             help_origin++;
  4560.         break;
  4561.       case K_Home:
  4562.       case K_EHome:
  4563.         pane_pos = help_origin = 0;
  4564.         break;
  4565.       case K_End:
  4566.       case K_EEnd:
  4567.         if (help_text_count > toplines - 1)
  4568.         { help_origin = help_text_count - toplines;
  4569.           pane_pos = toplines - 2;
  4570.         }
  4571.         else
  4572.         { help_origin = 0;
  4573.           pane_pos = help_text_count ? help_text_count - 1 : 0;
  4574.         }
  4575.         break;
  4576.       case K_PageDown:
  4577.       case K_EPageDown:
  4578.       case K_Control_V:
  4579.         if (help_origin + toplines <= help_text_count)
  4580.         { help_origin += toplines;
  4581.           if (help_origin + pane_pos >= help_text_count)
  4582.           pane_pos = help_text_count - 1 - help_origin;
  4583.         }
  4584.         break;
  4585.       case K_PageUp:
  4586.       case K_EPageUp:
  4587.         if (help_origin > toplines - 1)
  4588.           help_origin -= toplines - 1;
  4589.         else
  4590.           help_origin = pane_pos = 0;
  4591.         break;
  4592.       case K_Return:
  4593.       case K_Control_G:
  4594.       case K_Space:
  4595.         help_pane_active = 0;
  4596.         code_pane_active = 1;
  4597.         pane = 0;
  4598.         break;
  4599.     }
  4600.   }
  4601.   redraw (0);
  4602. }
  4603. /* ---------------------------------------------------------------------- */
  4604. static void
  4605. view_regs (void)
  4606. { WIN_TEXT read_text;  
  4607.   char *p;
  4608.   int i;
  4609.  
  4610.   init_text (&read_text, "Address Registers");
  4611.   p = malloc (max_cols + 5);
  4612.   for (i = 0; i < MAX_REGISTERS; i++)
  4613.   { sprintf (p, "Register[%c] == %08lx", i + '0', registers[i]);
  4614.     add_text (&read_text, p);
  4615.   }
  4616.   free (p);
  4617.   text_win (read_text, 40, 20);
  4618.   free_text (&read_text);
  4619. }
  4620. /* ---------------------------------------------------------------------- */
  4621. static void
  4622. resize_screen(void)
  4623. { int key, i;
  4624.  
  4625.   while (1)
  4626.   { redraw(-1);
  4627.     key = getykey();
  4628.     if (key == K_Escape)
  4629.     { key = getykey ();
  4630.       if (key == K_Escape)
  4631.         key = K_Control_G;
  4632.     }
  4633.     switch (key)
  4634.     { case K_Up:
  4635.       case K_EUp:
  4636.       case K_Control_P:
  4637.     if (toplines > 3)
  4638.     { toplines--;
  4639.       bottomlines++;
  4640.     }
  4641.     break;
  4642.       case K_Down:
  4643.       case K_EDown:
  4644.       case K_Control_N:
  4645.     if (toplines < rows - 4)
  4646.     { toplines++;
  4647.       bottomlines--;
  4648.     }
  4649.     break;
  4650.       case K_Left:
  4651.       case K_ELeft:
  4652.       case K_Control_B:
  4653.     switch (pane)
  4654.     { case 1:        /* Top middle   */
  4655.       case 2:        /* Top right    */
  4656.         if ((main_x2 > 3) && (main_x2 - main_x1 > 3))
  4657.           main_x2--;
  4658.         break;
  4659.       case 3:        /* Bottom right */
  4660.       case 4:        /* Bottom left  */
  4661.         if (main_x3 > 11 + 2 * data_dump_size)
  4662.           main_x3--;
  4663.         break;
  4664.       default:       /* Top left     */
  4665.         if (main_x1 > 3)
  4666.           main_x1--;
  4667.         break;
  4668.     }
  4669.     break;
  4670.       case K_Right:
  4671.       case K_ERight:
  4672.       case K_Control_F:
  4673.     switch (pane)
  4674.     { case 1:        /* Top middle   */
  4675.       case 2:        /* Top right    */
  4676.         if (main_x2 < cols - 4)
  4677.           main_x2++;
  4678.         break;
  4679.       case 3:        /* Bottom right */
  4680.       case 4:        /* Bottom left  */
  4681.         if (main_x3 < cols - 4)
  4682.           main_x3++;
  4683.         break;
  4684.       default:       /* Top left     */
  4685.         if ((main_x1 < cols - 4) && (main_x2 - main_x1 > 3))
  4686.           main_x1++;
  4687.         break;
  4688.     }
  4689.     break;
  4690.     }
  4691.     if (key == K_Return)
  4692.       break;
  4693.     if (key == K_Control_G)
  4694.       break;
  4695.   }
  4696.   for (i = 0; i < PANECOUNT; i++)
  4697.     switch(i)
  4698.     { case 3:        /* Bottom panes  */
  4699.       case 4:
  4700.     if (pane_positions[i] > bottomlines - 1)
  4701.       pane_positions[i] = bottomlines - 1;
  4702.     break;
  4703.       default:       /* Top panes     */
  4704.     if (pane_positions[i] > toplines - 1)
  4705.       pane_positions[i] = toplines - 1;
  4706.     break;
  4707.     }
  4708.   switch(pane)
  4709.   { case 3:        /* Bottom panes  */
  4710.     case 4:
  4711.       if (pane_pos > bottomlines - 1)
  4712.     pane_pos = bottomlines - 1;
  4713.       break;
  4714.     default:       /* Top panes     */
  4715.       if (pane_pos > toplines - 1)
  4716.     pane_pos = toplines - 1;
  4717.       break;
  4718.   }
  4719.   redraw(0);
  4720. }
  4721. /* ---------------------------------------------------------------------- */
  4722. static void
  4723. setup_io(void)
  4724. {
  4725.   if (!my_read_string("Redirect IO to device: "))
  4726.   {
  4727.     if (strncmp (read_buffer, "con", 3) == 0)
  4728.       using_com_port_num = 0;
  4729.     if (strncmp (read_buffer, "com_one", 7) == 0)
  4730.       using_com_port_num = 1;
  4731.     if (strncmp (read_buffer, "com_two", 7) == 0)
  4732.       using_com_port_num = 2;
  4733.     if (strncmp (read_buffer, "com_three", 9) == 0)
  4734.       using_com_port_num = 3;
  4735.     if (strncmp (read_buffer, "com_four", 8) == 0)
  4736.       using_com_port_num = 4;
  4737.     if (using_com_port_num)
  4738.     { re_init_io (using_com_port_num, rows, cols); 
  4739.       toplines = (rows / 2) + 4;
  4740.       bottomlines = rows - 3 - toplines;
  4741.       main_x1 = cols - 18;
  4742.       main_x2 = cols - 5;
  4743.       main_x3 = 46;
  4744.     }
  4745.     free (code_pane_pos);
  4746.     free (stack_dump_pos);
  4747.     code_pane_pos = malloc ((rows + 2) * sizeof (word32));
  4748.     stack_dump_pos = malloc ((rows + 2) * sizeof (word32));
  4749.     free (debug_screen_save);
  4750.     free (user_screen_save);
  4751.     debug_screen_save = get_screen ();
  4752.     debug_screen_save[1] = debug_screen_save[2] = 0;
  4753.     user_screen_save = get_screen ();
  4754.     user_screen_save[1] = debug_screen_save[2] = 0;
  4755.   }
  4756.   redraw (0);
  4757. }
  4758. /* ---------------------------------------------------------------------- */
  4759. static void
  4760. setup_screen(void)
  4761. {
  4762.   int new_cols, new_rows;
  4763.  
  4764.   if (!my_read_string("Columns: "))
  4765.     {
  4766.       char *endp;
  4767.  
  4768.       new_cols = strtoul(read_buffer, &endp, 10);
  4769.       if (new_cols == 0)
  4770.     new_cols = cols;
  4771.     }
  4772.   else
  4773.     new_cols = cols;
  4774.  
  4775.   if (new_cols < 20)
  4776.     new_cols = 20;
  4777.   if (new_cols > max_cols)
  4778.     new_cols = max_cols;
  4779.  
  4780.   if (!my_read_string("Rows: "))
  4781.     {
  4782.       char *endp;
  4783.  
  4784.       new_rows = strtoul(read_buffer, &endp, 10);
  4785.       if (new_rows == 0)
  4786.     new_rows = rows;
  4787.     }
  4788.   else
  4789.     new_rows = rows;
  4790.  
  4791.   if (new_rows < 15)
  4792.     new_rows = 15;
  4793.   if (new_rows > max_rows)
  4794.     new_rows = max_rows;  
  4795.   
  4796.   re_init_io (using_com_port_num, new_rows, new_cols);
  4797.  
  4798.   toplines = (rows / 2) + 4;
  4799.   bottomlines = rows - 3 - toplines;
  4800.   main_x1 = cols - 18;
  4801.   main_x2 = cols - 5;
  4802.   main_x3 = 46;
  4803.   if (main_x3 > cols)
  4804.     main_x3 = cols - 10;
  4805.  
  4806.   free (code_pane_pos);
  4807.   free (stack_dump_pos);
  4808.  
  4809.   code_pane_pos = malloc ((rows + 2) * sizeof (word32));
  4810.   stack_dump_pos = malloc ((rows + 2) * sizeof (word32));
  4811.  
  4812.   free (debug_screen_save);
  4813.   debug_screen_save = get_screen ();
  4814.   debug_screen_save[1] = debug_screen_save[2] = 0;  /* Patch cursor pos.  */
  4815.  
  4816.   redraw (0);
  4817. }
  4818. /* ---------------------------------------------------------------------- */
  4819. static void
  4820. make_pane_name (void)
  4821. { switch (pane)
  4822.   { case CODE_PANE_NUM:
  4823.       sprintf (active_pane_name, "Code Pane");
  4824.       break;
  4825.     case NPX_PANE_NUM:
  4826.       sprintf (active_pane_name, "NPX Pane");
  4827.       break;
  4828.     case STACK_PANE_NUM:
  4829.       sprintf (active_pane_name, "Stack Pane");
  4830.       break;
  4831.     case INFO_PANE_NUM:
  4832.       sprintf (active_pane_name, "Info Pane");
  4833.       break;
  4834.     case WHEREIS_PANE_NUM:
  4835.       sprintf (active_pane_name, "WhereIs Pane");
  4836.       break;
  4837.     case MODULE_PANE_NUM:
  4838.       sprintf (active_pane_name, "Module Pane");
  4839.       break;
  4840.     case HELP_PANE_NUM:
  4841.       sprintf (active_pane_name, "Help Pane");
  4842.       break;
  4843.   }
  4844. }
  4845. /* ---------------------------------------------------------------------- */
  4846. static int
  4847. make_pane_from_key (int key)
  4848. { switch (key)
  4849.   { case 'B':
  4850.     case 'b':
  4851.       return (203);
  4852.       break;
  4853.     case 'C':
  4854.     case 'c':
  4855.       return (204);
  4856.       break;        
  4857.     case 'D':
  4858.     case 'd':
  4859.       return (205);
  4860.       break;        
  4861.     case 'F':
  4862.     case 'f':
  4863.       return (206);
  4864.       break;        
  4865.     case 'H':
  4866.     case 'h':
  4867.       return (207);
  4868.       break;        
  4869.     case 'I':
  4870.     case 'i':
  4871.       return (208);
  4872.       break;        
  4873.     case 'M':
  4874.     case 'm':
  4875.       return (209);
  4876.       break;        
  4877.     case 'N':
  4878.     case 'n':
  4879.       return (210);
  4880.       break;        
  4881.     case 'R':
  4882.     case 'r':
  4883.       return (211);
  4884.       break;        
  4885.     case 'S':
  4886.     case 's':
  4887.       return (212);
  4888.       break;        
  4889.     case 'W':
  4890.     case 'w':
  4891.       return (213);
  4892.       break;        
  4893.     default:
  4894.       return (999);
  4895.       break;
  4896.   }    
  4897. }
  4898. /* ---------------------------------------------------------------------- */
  4899. static void
  4900. log_current_pane (void)
  4901. { switch (pane)    /* focused pane */
  4902.   { case 1:        /* Top middle */
  4903.       write_log (main_x1 + 1, 2, main_x2, toplines + 1);
  4904.       break;
  4905.     case 2:        /* Top right */
  4906.       write_log (main_x2 + 1, 2, cols - 1, toplines + 1);
  4907.       break;
  4908.     case 3:        /* Bottom right */
  4909.       write_log (main_x3+1, toplines+2, cols-1, rows-1);
  4910.       break;
  4911.     case 4:        /* Bottom left */
  4912.       write_log (1, toplines + 2, main_x3, rows - 1);
  4913.       break;
  4914.     default:       /* Top Left */
  4915.       write_log (1, 2, main_x1, toplines + 1);
  4916.       break;
  4917.   }
  4918. }
  4919. /* ---------------------------------------------------------------------- */
  4920. static void
  4921. current_pane_taller (void)
  4922. { switch (pane)
  4923.   { case 3:  /* Breakpoint */
  4924.     case 4:  /* Data       */   
  4925.       if (toplines > 3)
  4926.       { toplines--;
  4927.         bottomlines++;
  4928.       }
  4929.       break;
  4930.     default:
  4931.       if (bottomlines > 1)
  4932.       { toplines++;
  4933.         bottomlines--;
  4934.       }
  4935.       break;
  4936.   }    
  4937.   redraw (0);
  4938. }
  4939. /* ---------------------------------------------------------------------- */
  4940. static void
  4941. current_pane_wider (void)
  4942. { switch (pane)
  4943.   { case 1:  /* Register   */          
  4944.       if (main_x1 > 3)
  4945.         main_x1--;
  4946.       break;
  4947.     case 2:  /* Flag       */ 
  4948.       break;                             /* No need to enlarge flag pane */
  4949.     case 3:  /* Breakpoint */ 
  4950.       if (main_x3 > 11 + 2 * data_dump_size)
  4951.         main_x3--;   
  4952.       break;
  4953.     case 4:  /* Data       */ 
  4954.       if (main_x3 < cols - 4)
  4955.         main_x3++;
  4956.       break;
  4957.     default: /* TopLeftPane*/ 
  4958.       if ((main_x1 < cols - 4) && (main_x2 - main_x1 > 3))
  4959.         main_x1++;
  4960.       break; 
  4961.   } 
  4962.   redraw (0);
  4963. }
  4964. /* ---------------------------------------------------------------------- */
  4965. static char *
  4966. addr_to_str (char *output, word32 addr)
  4967. { char *name;
  4968.   int32 delta;
  4969.   
  4970.   name = syms_val2name (addr, &delta);
  4971.   if (name[0] != '0')
  4972.     if (delta)
  4973.       sprintf (output, "%s+%#lx", name, delta);
  4974.     else
  4975.       sprintf (output, "%s", name);
  4976.   else
  4977.     sprintf(output,"0x%08lx",addr);
  4978.   return (output);
  4979. }
  4980. /* ---------------------------------------------------------------------- */
  4981. static void
  4982. breakpoint_to_str (char *str, int class, int type, word32 addr,
  4983.                    int length, int count, char *cond)
  4984. { char temp[200];
  4985.  
  4986.   sprintf (str, "-class %s -type %s -at %s -length %d ",
  4987.            class == 0 ? "normal" : class == 1 ? "count_down" : "conditional",
  4988.            type == 0 ? "code" : type == 1 ? "data_write" : "data_read",
  4989.            addr_to_str (temp, addr),
  4990.            length
  4991.           );
  4992.   if (class == 1)
  4993.     sprintf (str + strlen (str), "-count %d", count);
  4994.   if (class == 2)
  4995.     sprintf (str + strlen (str), "-condition %s", cond);
  4996.   sprintf (str + strlen (str), "%c\n", 0x0d);
  4997. }
  4998. /* ---------------------------------------------------------------------- */
  4999. static PARSE_DEF bp_def[] = {
  5000.        {"-class"    , STR_TYPE, {0}},
  5001.        {"-type"     , STR_TYPE, {0}},
  5002.        {"-at"       , STR_TYPE, {0}},
  5003.        {"-length"   , INT_TYPE, {0}},
  5004.        {"-count"    , INT_TYPE, {0}},
  5005.        {"-condition", STR_TYPE, {0}},
  5006.        {0           , 0       , {0}}
  5007. };
  5008. /* ---------------------------------------------------------------------- */
  5009. static int
  5010. str_to_breakpoint (char *str, int *class, int *type, word32 *addr,
  5011.                    int *length, int *count, char *cond)
  5012. { int ok;
  5013.   char s_class[64], s_type[64], s_addr[128];
  5014.  
  5015.   s_class[0] = 0; bp_def[0].val.s_val = s_class;
  5016.   s_type[0]  = 0; bp_def[1].val.s_val = s_type;
  5017.   s_addr[0]  = 0; bp_def[2].val.s_val = s_addr;
  5018.   *length    = 4; bp_def[3].val.i_val = length;
  5019.   *count     = 0; bp_def[4].val.i_val = count;
  5020.   cond[0]    = 0; bp_def[5].val.s_val = cond;
  5021.   
  5022.   parse_string (bp_def, str);
  5023.   if (stricmp (s_class, "count_down") == 0)
  5024.     *class = 1;
  5025.   else if (stricmp (s_class, "conditional") == 0)
  5026.     *class = 2;
  5027.   else
  5028.     *class = 0;
  5029.   if (stricmp (s_type, "data_write") == 0)
  5030.     *type = 1;
  5031.   else if (stricmp (s_type, "data_read") == 0)
  5032.     *type = 3;
  5033.   else
  5034.     *type = 0;
  5035.   *addr = parse_expression (4, s_addr, &ok);
  5036.   if (ok != ParseError_ok)
  5037.     ok = 0;
  5038.   else
  5039.     ok = 1;
  5040.   if (*class == 2 && cond[0] == 0)
  5041.     ok = 0;
  5042.   return (ok);
  5043. }
  5044. /* ---------------------------------------------------------------------- */
  5045. static PARSE_DEF reg_def[] = {
  5046.        {"-number"   , STR_TYPE, {0}},
  5047.        {"-value"    , STR_TYPE, {0}},
  5048.        {0           , 0       , {0}}
  5049. };
  5050. /* ---------------------------------------------------------------------- */
  5051. static int
  5052. str_to_reg (char *str, char *index, word32 *addr)
  5053. { int ok;
  5054.   char s_index[32], s_addr[128];
  5055.   
  5056.   s_index[0] = 0; reg_def[0].val.s_val = s_index;
  5057.   s_addr[0]  = 0; reg_def[1].val.s_val = s_addr;
  5058.   
  5059.   parse_string (reg_def, str);
  5060.   if (s_index[0])
  5061.     *index = *s_index - '0';
  5062.   else
  5063.     return (0);
  5064.   *addr = parse_expression (4, s_addr, &ok);
  5065.   if (ok != ParseError_ok)
  5066.     return (0);
  5067.   return (1);
  5068. }
  5069. /* ---------------------------------------------------------------------- */
  5070. static PARSE_DEF pa_def[] = {
  5071.        {"-start"   , STR_TYPE, {0}},
  5072.        {"-stop"    , STR_TYPE, {0}},
  5073.        {0          , 0       , {0}}
  5074. };
  5075. /* ---------------------------------------------------------------------- */
  5076. static int
  5077. str_to_pa (char *str, word32 *addr1, word32 *addr2)
  5078. { int ok;
  5079.   char s_start[128], s_stop[128];
  5080.   
  5081.   s_start[0] = 0; pa_def[0].val.s_val = s_start;
  5082.   s_stop[0]  = 0; pa_def[1].val.s_val = s_stop;
  5083.   
  5084.   parse_string (pa_def, str);
  5085.   *addr1 = parse_expression (4, s_start, &ok);
  5086.   if (ok != ParseError_ok)
  5087.     return (0);
  5088.   *addr2 = parse_expression (4, s_stop, &ok);
  5089.   if (ok != ParseError_ok)
  5090.     return (0);
  5091.   return (1);
  5092. }
  5093. /* ---------------------------------------------------------------------- */
  5094. static PARSE_DEF pane_def[] = {
  5095.        {"-top_lines"    , INT_TYPE, {0}},
  5096.        {"-top_left_cols", INT_TYPE, {0}},
  5097.        {"-top_mid_cols" , INT_TYPE, {0}},
  5098.        {"-bot_left_cols", INT_TYPE, {0}},
  5099.        {0               , 0       , {0}}
  5100. };
  5101. /* ---------------------------------------------------------------------- */
  5102. static int
  5103. str_to_pane (char *str, int *tl, int *x1, int *x2, int *x3)
  5104. { pane_def[0].val.i_val = tl;
  5105.   pane_def[1].val.i_val = x1;
  5106.   pane_def[2].val.i_val = x2;
  5107.   pane_def[3].val.i_val = x3;
  5108.  
  5109.   parse_string (pane_def, str);
  5110.   return (1);
  5111. }
  5112. /* ---------------------------------------------------------------------- */
  5113. static int
  5114. save_context (int save_bp, int save_reg, int save_pa, int save_pane, 
  5115.               char *filename)
  5116. { FILE *f;
  5117.   int i;
  5118.   char temp[200];
  5119.  
  5120.   f = fopen (filename, "wb");
  5121.   if (!f)
  5122.     return (0);
  5123.   if (save_bp)
  5124.   { fputs ("##\015\n", f);
  5125.     fputs ("# Breakpoint information\015\n", f);
  5126.     fputs ("##\015\n", f);
  5127.     fputs (" \015\n", f);
  5128.     for (i = 0; i < breakpoint_count; i++)
  5129.     { sprintf (read_buffer, "bre ");
  5130.       breakpoint_to_str (read_buffer + strlen (read_buffer),
  5131.                          breakpoint_table[i].sub_type,
  5132.                          breakpoint_table[i].type,
  5133.                          breakpoint_table[i].addr,
  5134.                          breakpoint_table[i].length,
  5135.                          breakpoint_table[i].count,
  5136.                          breakpoint_table[i].condition
  5137.                         );
  5138.       fputs (read_buffer, f);
  5139.     }
  5140.     fputs (" \015\n", f);
  5141.   }
  5142.   if (save_reg)
  5143.   { fputs ("##\015\n", f);
  5144.     fputs ("# Debugger registers\015\n", f);
  5145.     fputs ("##\015\n", f);
  5146.     fputs (" \015\n", f);
  5147.     for (i = 0; i < MAX_REGISTERS; i++)
  5148.       if (registers[i])
  5149.       { sprintf (read_buffer, "reg -number %c -value %s\015\n",
  5150.                  i + '0',
  5151.                  addr_to_str (temp, registers[i])
  5152.                 );
  5153.         fputs (read_buffer, f);
  5154.       }
  5155.     fputs (" \015\n", f);
  5156.   }
  5157.   if (save_pa)
  5158.   { fputs ("##\015\n", f);
  5159.     fputs ("# Performance Analyzer\015\n", f);
  5160.     fputs ("##\015\n", f);
  5161.     fputs (" \015\n", f);
  5162.     sprintf (read_buffer, "pa -start %s ",
  5163.              addr_to_str (temp, evaluation_data[0].start_addr)
  5164.             );
  5165.     sprintf (read_buffer + strlen (read_buffer), "-stop %s\015\n",
  5166.              addr_to_str (temp, evaluation_data[EVAL_SEGMENTS - 1].stop_addr)
  5167.             );
  5168.     fputs (read_buffer, f);
  5169.     fputs (" \015\n", f);
  5170.   }
  5171.   if (save_pane)
  5172.   { fputs ("##\015\n", f);
  5173.     fputs ("# Pane information\015\n", f);
  5174.     fputs ("##\015\n", f);
  5175.     fputs (" \015\n", f);
  5176.     sprintf (read_buffer,
  5177.              "pane -top_lines %d -top_left_cols %d -top_mid_cols %d -bot_left_cols %d\015\n",
  5178.              toplines, main_x1 - 1, main_x2 - main_x1 - 1, main_x3 - 1
  5179.             );
  5180.     fputs (read_buffer, f);
  5181.     fputs (" \015\n", f);
  5182.   }
  5183.   fclose (f);
  5184.   return (1);
  5185. }
  5186. /* ---------------------------------------------------------------------- */
  5187. static int
  5188. load_context (int load_bp, int load_reg, int load_pa, int load_pane, 
  5189.               char *filename, int startup_load)
  5190. { FILE *f;                                                               
  5191.   int err, temp;
  5192.   char command[64];
  5193.  
  5194.   if (startup_load)
  5195.   { f = fopen (startup_file, "rb");
  5196.     if (!f)
  5197.       return (0);
  5198.   } else
  5199.   { f = fopen (filename, "rb");
  5200.     if (!f)
  5201.     { message (CL_Error, "Error reading from file %s", filename);
  5202.       return (0);
  5203.     }
  5204.   }
  5205.   err = load_bp +
  5206.         ((load_reg & 1) << 1) +
  5207.         ((load_pa & 1) << 2) +
  5208.         ((load_pane & 1) << 3);
  5209.   while (fgets (read_buffer, 1024, f))
  5210.   { read_buffer[strlen (read_buffer) - 1] = 0;
  5211.     if (sscanf (read_buffer, "%s%n", command, &temp) >= 1)
  5212.     { if (stricmp (command, "bre") == 0)
  5213.       { if (load_bp)
  5214.         { int class, type, length, count;
  5215.           word32 addr;
  5216.           char cond[200];
  5217.  
  5218.           count = 0;
  5219.           cond[0] = 0;
  5220.           str_to_breakpoint (read_buffer + temp,
  5221.                              &class, &type, &addr, &length, &count, cond);
  5222.           temp = set_breakpoint (type, length, addr);
  5223.           breakpoint_table[temp].sub_type = class;
  5224.           breakpoint_table[temp].count = count;
  5225.           strcpy (breakpoint_table[temp].condition, cond);
  5226.         }
  5227.         err &= ~1;
  5228.       } else if (stricmp (command, "reg") == 0)
  5229.       { if (load_reg)
  5230.     { char index;
  5231.       word32 addr;
  5232.  
  5233.       if (str_to_reg ((char *)(read_buffer + temp), &index, &addr))
  5234.       { registers[(int)index] = addr;
  5235.             err &= ~2;
  5236.           }
  5237.         }
  5238.       } else if (stricmp (command, "pa") == 0)
  5239.       { if (load_pa)
  5240.         { word32 addr1, addr2;
  5241.  
  5242.       if (str_to_pa ((char *)(read_buffer + temp), &addr1, &addr2))
  5243.       { init_eval_data (addr1, addr2);
  5244.         err &= ~4;
  5245.       }
  5246.     }
  5247.       } else if (stricmp (command, "pane") == 0)
  5248.       { if (load_pane)
  5249.     { int tl = 0, x1 = 0, x2 = 0, x3 = 0;
  5250.  
  5251.       if (str_to_pane ((char *)(read_buffer + temp), &tl, &x1, &x2, &x3))
  5252.       { if (tl < rows - 5 && tl > 3)
  5253.         { toplines = tl;
  5254.           bottomlines = rows - 4 - toplines;
  5255.         }
  5256.         if (x1 > 1 && x1 < cols - 5)
  5257.         { main_x1 = x1 + 1;
  5258.           if (main_x2 - main_x1 < 2)
  5259.         main_x2 = main_x1 + 2;
  5260.         }
  5261.         if (x2 > 0 && main_x1 + x2 < cols - 2)
  5262.           main_x2 = main_x1 + x2 + 1;
  5263.         if (x3 > 11 + 2 * data_dump_size && main_x3 < cols - 5)
  5264.           main_x3 = x3 + 1;
  5265.         err &= ~8;
  5266.       }
  5267.     }
  5268.       }
  5269.     }
  5270.   }
  5271.   fclose (f);
  5272.   if (startup_load)
  5273.     return (1);
  5274.   redraw (0);
  5275.   if (err)
  5276.     message (CL_Error, "File has no %s%s%s%s information",
  5277.          err & 1 ? "breakpoints" : "",
  5278.              err & 2 ? (err & 1 ? ", registers" : "registers") : "",
  5279.              err & 4 ? (err & 3 ? ", P.A. data" : "P.A. data") : "",
  5280.              err & 8 ? (err & 7 ? ", pane layouts" : "pane layouts") : "");
  5281.   else
  5282.     message (CL_Info, "Requested context has been successfully loaded.");
  5283.   return (1);
  5284. }
  5285. /* ---------------------------------------------------------------------- */
  5286. static void
  5287. in_ck (char *output, char *input, word32 addr)
  5288. { sprintf (output, "%s", *(int *)addr ? "[X]" : "[ ]");
  5289. }
  5290. /* ---------------------------------------------------------------------- */
  5291. static int
  5292. ed_ck (char *text, word32 addr, int x, int y, int len, int *key)
  5293. { if (*key == K_Return || *key == K_Space)/* Only these keys are accepted */
  5294.   { if (*(int *)addr)
  5295.       *(int *)addr = 0;
  5296.     else
  5297.       *(int *)addr = 1;
  5298.   }
  5299.   *key = 0;
  5300.   return 1;
  5301. }          
  5302. /* ---------------------------------------------------------------------- */
  5303. static void
  5304. save_load_context (void)
  5305. { int ret = 7;
  5306.   static int save_bp = 1, save_reg = 0, save_pa = 0, save_pane = 0;
  5307.   static char ct_filename[81];
  5308.   static DIALOG_ITEM dialog_data[] = {
  5309.     {"Breakpoints          :", 0 , 03, 1, format_asis, eval_word, in_ck    , ed_ck },
  5310.     {"Registers            :", 0 , 03, 1, format_asis, eval_word, in_ck    , ed_ck },
  5311.     {"Performance Analizer :", 0 , 03, 1, format_asis, eval_word, in_ck    , ed_ck },
  5312.     {"Pane positions       :", 0 , 03, 1, format_asis, eval_word, in_ck    , ed_ck },
  5313.     {"Filename             :", 0 , 80, 1, format_asis, eval_asis, init_asis, editor},
  5314.     {0                       , 0 , 00 ,0, 0          , 0        , 0        , 0     }
  5315.   };
  5316.   static BUTTON_ITEM button_data[] = {
  5317.     {"  Save  ", 0, action_done},
  5318.     {"  Load  ", 0, action_done},
  5319.     {" Cancel ", 0, action_done},
  5320.     {0         , 0, 0          }
  5321.   };
  5322.  
  5323.   dialog_data[0].return_addr = (word32)&save_bp;
  5324.   dialog_data[1].return_addr = (word32)&save_reg;
  5325.   dialog_data[2].return_addr = (word32)&save_pa;
  5326.   dialog_data[3].return_addr = (word32)&save_pane;
  5327.   dialog_data[4].return_addr = (word32)&ct_filename;
  5328.   dialog ("Debugger Context", dialog_data, button_data, &ret);
  5329.   switch (ret)
  5330.   { case 1:
  5331.       if (ct_filename[0])
  5332.         if (save_context (save_bp, save_reg, save_pa, save_pane, ct_filename))
  5333.            message (CL_Info, "Requested context has been successfully saved.");
  5334.         else
  5335.            message (CL_Error, "Error writing to file %s", ct_filename);
  5336.       break;
  5337.     case 2:
  5338.       if (ct_filename[0])
  5339.         load_context (save_bp, save_reg, save_pa, save_pane, ct_filename, 0);
  5340.       break;
  5341.     default:
  5342.       redraw (0);
  5343.   }
  5344. }
  5345. /* ---------------------------------------------------------------------- */
  5346. void
  5347. debugger (void)
  5348. {
  5349.   int oldpane, lastpane, bar_select, pop_select, command;
  5350.   static void (*keyhandlers[PANECOUNT])(int) =
  5351.     {
  5352.       &code_pane_command,          /*  0 */
  5353.       ®ister_pane_command,      /*  1 */
  5354.       &flag_pane_command,          /*  2 */
  5355.       &breakpoint_pane_command,    /*  3 */
  5356.       &data_pane_command,          /*  4 */
  5357.       &npx_pane_command,           /*  5 */
  5358.       &stack_pane_command,         /*  6 */
  5359.       &info_pane_command,          /*  7 */
  5360.       &whereis_pane_command,       /*  8 */
  5361.       &module_pane_command,        /*  9 */
  5362.       &help_pane_command           /* 10 */
  5363.     };
  5364.  
  5365.   main_entry = syms_name2val ("_main");
  5366.   first_step = !undefined_symbol;
  5367.   initialize ();
  5368.   if (startup_file[0] != 0)
  5369.     if (load_context (1, 1, 1, 1, startup_file, 1))
  5370.       message (CL_Info, "Succesfully loaded start-up file %s.", startup_file);
  5371.   can_longjmp = 1;
  5372.   setjmp (debugger_jmpbuf);
  5373.   lastpane = oldpane = -1;                           
  5374.   show_menu_bar (Main_Menu);
  5375.   Main_Menu[0].type = 1;
  5376.  
  5377.   while (1)
  5378.     {
  5379.       int key;
  5380.  
  5381.       if (pane < 1 || pane > 4)
  5382.     pane = code_pane_active ? 0
  5383.       : (npx_pane_active ? 5
  5384.          : (stack_pane_active ? 6
  5385.         : (info_pane_active ? 7
  5386.            : (whereis_pane_active ? 8
  5387.               : (module_pane_active ? 9
  5388.              : (help_pane_active ? 10
  5389.                 : (abort (), -1)))))));
  5390.       if (pane == oldpane)
  5391.     pane_positions[pane] = pane_pos;
  5392.       else
  5393.     {
  5394.       pane_pos = pane_positions[pane];
  5395.           lastpane = oldpane;
  5396.       oldpane = pane;
  5397.           make_pane_name ();
  5398.       redraw (0);
  5399.           if (whereis_pane_active && !whereis_sym_count)
  5400.              init_whereis_sym ();
  5401.     } 
  5402.       escaped   = 0; 
  5403.       control_c = 0;
  5404.       control_x = 0;
  5405.       switch (key = getykey ()) 
  5406.       { case K_Escape:
  5407.           escaped = 1;
  5408.           key = getykey ();
  5409.           break;
  5410.         case K_Control_C:
  5411.           control_c = 1;
  5412.           key = getykey ();
  5413.           break;
  5414.         case K_Control_X:
  5415.           control_x = 1;
  5416.           key = getykey ();
  5417.           break;
  5418.       }                  
  5419.       command = 0; 
  5420.       if (escaped)
  5421.         switch (key)
  5422.     { case K_Escape:                  /* Esc-Esc           */           
  5423.             pop_select = 0;
  5424.             if (!running_xsupport)
  5425.             { menu (Main_Menu, &bar_select, &pop_select);
  5426.               command = bar_select * 100 + pop_select;  
  5427.             } else
  5428.             { command = 999;
  5429.               if (extern_data_support (data_dump_origin + 
  5430.                    pane_positions[DATA_PANE_NUM]))
  5431.               { running_xsupport = 0;
  5432.                 redraw (0);
  5433.               }
  5434.             }
  5435.             break;
  5436.           case K_Control_P:               /* Esc-^P            */
  5437.             key = getykey ();
  5438.             command = make_pane_from_key (key);
  5439.             break;     
  5440.           default:
  5441.             command = 0;
  5442.             break;
  5443.         }                                                        
  5444.       if (control_x)
  5445.       { command = 999;
  5446.         switch (key)
  5447.     { case K_Control_C:               /* <=> F-Exit        */
  5448.             if (confirm ("Are you sure (y/n)? "))
  5449.               command = 108;
  5450.             break;
  5451.       case K_Control_V:               /* <=> F-Context     */
  5452.             command = 107;
  5453.             break;
  5454.       case K_Control_W:               /* Write Log         */
  5455.             log_current_pane ();
  5456.             break;
  5457.       case K_Control_F:               /* Read Log          */
  5458.             read_log ();
  5459.             break;
  5460.       case K_Control_E:               /* <=> M-Evaluate    */
  5461.             command = 402;
  5462.             break;                                       
  5463.           case K_Control_X:               /* Prev. Reflexive   */
  5464.             if ((lastpane >= 0) && (lastpane < PANECOUNT))
  5465.             { command = pane;
  5466.               pane = lastpane;
  5467.               lastpane = command;
  5468.               command = 999;
  5469.             } 
  5470.             break;
  5471.           case '^':                       /* Taller            */
  5472.             current_pane_taller ();
  5473.             break;
  5474.           case '}':                       /* Wider             */
  5475.             current_pane_wider ();
  5476.             break;
  5477.       case '<':                       /* Scroll left       */
  5478.             pane_offset[pane] += SCROLL_COUNT; 
  5479.             redraw (0);
  5480.             break;       
  5481.       case '>':                       /* Scroll right      */
  5482.             if (pane_offset[pane] > 0)
  5483.               pane_offset[pane] -= SCROLL_COUNT; 
  5484.             redraw (0);
  5485.             break;        
  5486.           case 'm':                       /* Color / Mono      */
  5487.           case 'M':
  5488.             if (screen_attr_normal == screen_attr_asm)
  5489.               command = 105;
  5490.             else
  5491.               command = 104;
  5492.             break;
  5493.           case 'o':
  5494.           case 'O':                       /* Next pane == Tab  */
  5495.             control_x = 0;
  5496.             key = K_Tab;
  5497.             break;
  5498.           default:
  5499.             command = 0;
  5500.             break;
  5501.         }             
  5502.       }
  5503.       if (control_c)
  5504.       { command = 0;                      /* No command defined*/
  5505.       }
  5506.       if (!(escaped || control_x || control_c))
  5507.       { command = 999;
  5508.         switch (key)
  5509.     { case K_Tab:                                            
  5510.             if (pane < 1 || pane > 4)
  5511.           pane = 1;
  5512.             else
  5513.           pane++;
  5514.         break;
  5515.           case K_BackTab:  
  5516.             if (pane < 1 || pane > 4)
  5517.               pane = 4;
  5518.             else
  5519.               pane--;
  5520.             break;
  5521.           case K_Control_H:            /* Global - Help    */
  5522.             command = 207;
  5523.             break;         
  5524.           case K_Control_R:            /* Global - Run     */
  5525.             step (2);                                          
  5526.             break;         
  5527.           case K_Control_L:            /* Global - Refresh */
  5528.             command = 403;
  5529.             break;
  5530.           case K_Control_Z:            /* Global - User Scr*/
  5531.             command = 401;
  5532.             break;
  5533.           default:    
  5534.             command = 0;
  5535.             break;
  5536.         }               
  5537.       }
  5538.       switch (command)
  5539.       {  case 101:                     /* File - Log       */
  5540.         switch (pane)    /* focused pane */
  5541.         { case 1:        /* Top middle */
  5542.            read_write_log (main_x1 + 1, 2, main_x2, toplines + 1);
  5543.            break;
  5544.          case 2:        /* Top right */
  5545.            read_write_log (main_x2 + 1, 2, cols - 1, toplines + 1);
  5546.            break;
  5547.          case 3:        /* Bottom right */
  5548.            read_write_log (main_x3+1, toplines+2, cols-1, rows-1);
  5549.            break;
  5550.          case 4:        /* Bottom left */
  5551.            read_write_log (1, toplines + 2, main_x3, rows - 1);
  5552.            break;
  5553.          default:       /* Top Left */
  5554.            read_write_log (1, 2, main_x1, toplines + 1);
  5555.            break;
  5556.        }
  5557.        break;
  5558.          case 102:                    /* File - Registers */
  5559.            view_regs ();
  5560.            break;
  5561.          case 103:                    /* File - Resize    */
  5562.            setup_screen ();
  5563.            break;
  5564.          case 104:                    /* File - Mono mode */
  5565.            init_color (0);
  5566.            oldpane = -1;
  5567.            break;
  5568.          case 105:                    /* File - Color    */
  5569.            init_color (1);
  5570.            oldpane = -1;
  5571.            break;
  5572.          case 106:                    /* File - Redirect */
  5573.            setup_io();
  5574.            break; 
  5575.          case 107:                    /* File - Context  */
  5576.            save_load_context ();
  5577.            break;
  5578.          case 108:                    /* File - Exit     */
  5579.            user_screen ();
  5580.            can_longjmp = 0;
  5581.            if (using_com_port_num)
  5582.              com_done();
  5583.            if (timer_is_set)
  5584.              reset_timer ();
  5585.            return;
  5586.          case 201:                    /* Pane - Previous */
  5587.            if (pane < 1 || pane > 4)
  5588.              pane = 4;
  5589.            else
  5590.              pane--;
  5591.            break;
  5592.          case 202:                    /* Pane - Next     */
  5593.            if (pane < 1 || pane > 4)
  5594.              pane = 1;
  5595.            else
  5596.              pane++;
  5597.            break;
  5598.          case 203:                    /* Pane - Data     */
  5599.            pane = 3;
  5600.            break;
  5601.          case 205:                    /* Pane - Breakpoin*/
  5602.            pane = 4;
  5603.            break;
  5604.          case 206:                    /* Pane - Flags    */
  5605.            pane = 2;
  5606.            break;
  5607.          case 211:                    /* Pane - Registers*/
  5608.            pane = 1;
  5609.            break;
  5610.          case 204:                    /* Pane - Code     */
  5611.          case 207:                    /* Pane - Help     */
  5612.          case 208:                    /* Pane - Info     */
  5613.          case 209:                    /* Pane - Module   */
  5614.          case 210:                    /* Pane - Npx      */
  5615.          case 212:                    /* Pane - Stack    */
  5616.          case 213:                    /* Pane - Where-is */
  5617.            code_pane_active    = (command == 204);
  5618.            help_pane_active    = (command == 207);
  5619.            info_pane_active    = (command == 208);
  5620.            module_pane_active  = (command == 209);
  5621.            npx_pane_active     = (command == 210);
  5622.            stack_pane_active   = (command == 212);
  5623.               whereis_pane_active = (command == 213);
  5624.            pane = 0;                                                     
  5625.            if (npx_pane_active && !has_npx)
  5626.            { message (CL_Error, "NPX not present");
  5627.              npx_pane_active = 0;
  5628.              code_pane_active = 1;
  5629.            }
  5630.            break;
  5631.          case 214:                    /* Pane - Resize   */
  5632.            resize_screen();
  5633.            show_menu_bar (Main_Menu);
  5634.            oldpane = -1; /* Force redraw.  */
  5635.            break;
  5636.          case 300:                    /* Local */
  5637.            keyhandlers[pane] (0);
  5638.            break;
  5639.          case 401:                    /* Misc - User Scre*/
  5640.            user_screen ();
  5641.            (void) getykey ();
  5642.            debug_screen ();
  5643.            break;
  5644.          case 402:                    /* Misc - Evaluate */
  5645.          { int res, ok;
  5646.            res = read_eval (&ok, "");
  5647.            if (ok)
  5648.              message (CL_Msg, "\"%s\" -> %d (0x%08lx)",
  5649.                   read_buffer, res, (word32) res);
  5650.            break;
  5651.          }
  5652.          case 403:                    /* Misc - Refresh  */
  5653.            re_start_transfer ();
  5654.            redraw (0);
  5655.            break;
  5656.          case 501:                    /* Help - About    */
  5657.            message (CL_Info, 
  5658.                     "Ladybug version %d.%02d", MAJOR_VER, MINOR_VER);
  5659.            break;
  5660.          case 502:                    /* Help - Help     */
  5661.            code_pane_active    = 0;
  5662.            info_pane_active    = 0;
  5663.            module_pane_active  = 0;
  5664.            npx_pane_active     = 0;
  5665.            stack_pane_active   = 0;
  5666.               whereis_pane_active = 0;
  5667.            help_pane_active    = 1;
  5668.            oldpane = -1; /* Force redraw.  */
  5669.            break;
  5670.          case 999:                    /* Executed command*/
  5671.            break;
  5672.          default:                     /* Not global keys */
  5673.            keyhandlers[pane] (key);
  5674.            break;
  5675.       }          
  5676.     }
  5677. }
  5678. /* ----------------------------------------------------------------------
  5679.    It's a mystery to me --- the game commences
  5680.    for the usual fee --- plus expenses
  5681.    confidential information --- it's in a diary
  5682.    this is my investigation --- it's not a public inquiry
  5683.  
  5684.    -- Mark Knopfler, "Private Investigations"
  5685. ---------------------------------------------------------------------- */
  5686.